Reorganización de directorios

[config.git] / djavu-asus / emacs / elpa / s-20220902.1511 / s.elc

;ELC\1c\0\0\0
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(autoload 'slot-value "eieio")
#@50 Remove whitespace at the beginning of S.

(fn S)\1f
(defalias 's-trim-left #[257 "\300 \301\302\ 2\"\216\303\304\ 3\"\203\17\0\305\306\307\211\ 5$\202\18\0\ 1)\207" [match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] string-match "\\`[ 	\n\r]+" replace-match "" t] 7 (#$ . 115)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-trim-left pure t side-effect-free] 5)
#@44 Remove whitespace at the end of S.

(fn S)\1f
(defalias 's-trim-right #[257 "\300 \301\302\ 2\"\216\303\304\ 3\"\203\17\0\305\306\307\211\ 5$\202\18\0\ 1)\207" [match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] string-match "[ 	\n\r]+\\'" replace-match "" t] 7 (#$ . 524)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-trim-right pure t side-effect-free] 5)
#@58 Remove whitespace at the beginning and end of S.

(fn S)\1f
(defalias 's-trim #[257 "\300\301\ 2!!\207" [s-trim-left s-trim-right] 4 (#$ . 929)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-trim pure t side-effect-free] 5)
#@71 Convert all adjacent whitespace characters to a single space.

(fn S)\1f
(defalias 's-collapse-whitespace #[257 "\300\301\302\ 3#\207" [replace-regexp-in-string "[ 	\n\r]+" " "] 5 (#$ . 1181)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-collapse-whitespace pure t side-effect-free] 5)
#@142 Unindent S which has BOL (beginning of line) indicators.
BOL will default to pipe. You can optionally supply your own.

(fn S &optional BOL)\1f
(defalias 's-unindent #[513 "\301\ 1\206\ 6\0\302\ 1\18\303\304\305\ 3!P\306\ 6\ 6#)\207" [case-fold-search nil "|" s-replace-regexp "^[[:space:]]*" regexp-quote ""] 8 (#$ . 1496)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-unindent pure t side-effect-free] 5)
#@229 Split S into substrings bounded by matches for regexp SEPARATOR.
If OMIT-NULLS is non-nil, zero-length substrings are omitted.

This is a simple wrapper around the built-in `split-string'.

(fn SEPARATOR S &optional OMIT-NULLS)\1f
(defalias 's-split #[770 "\300 \301\302\ 2\"\216\303\ 3\ 5\ 4#)\207" [match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] split-string] 8 (#$ . 1920)])
(byte-code "\300\301\302\303#\300\207" [function-put s-split side-effect-free t] 4)
#@205 Split S up to N times into substrings bounded by matches for regexp SEPARATOR.

If OMIT-NULLS is non-nil, zero-length substrings are omitted.

See also `s-split'.

(fn SEPARATOR S N &optional OMIT-NULLS)\1f
(defalias 's-split-up-to #[1027 "\300 \301\302\ 2\"\216\303\304\305\306\307\"r\211q\210\301\310\ 2\"\216\ 6\ 6c\210eb\262\ 3\311\ 6\b\304\307#\203N\0\303\ 6\ 6W\203N\0\ 2\303\224{\ 5\203<\0\211\312\232\204A\0\211\ 3B\262\ 3\210\303\225b\262\ 3\ 5S\262\ 6\202\1e\0\ 2d{\ 5\203[\0\211\312\232\204`\0\211\ 3B\262\ 3\210*\210\211\237\266\202)\207" [match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] 0 nil generate-new-buffer " *temp*" t #[0 "\301\300!\205	\0\302\300!\207" [V0 buffer-name kill-buffer] 2] re-search-forward ""] 12 (#$ . 2413)])
(byte-code "\300\301\302\303#\300\207" [function-put s-split-up-to side-effect-free t] 4)
#@64 Splits S into a list of strings on newline characters.

(fn S)\1f
(defalias 's-lines #[257 "\300\301\ 2\"\207" [s-split "\\(\r\n\\|[\n\r]\\)"] 4 (#$ . 3236)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-lines pure t side-effect-free] 5)
#@84 Join all the strings in STRINGS with SEPARATOR in between.

(fn SEPARATOR STRINGS)\1f
(defalias 's-join #[514 "\300\301\ 2\ 4#\207" [mapconcat identity] 6 (#$ . 3500)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-join pure t side-effect-free] 5)
#@68 Join all the string arguments into one string.

(fn &rest STRINGS)\1f
(defalias 's-concat #[128 "\300\301\ 2\"\207" [apply concat] 4 (#$ . 3773)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-concat pure t side-effect-free] 5)
#@42 Concatenate PREFIX and S.

(fn PREFIX S)\1f
(defalias 's-prepend #[514 "\ 1\ 1P\207" [] 4 (#$ . 4028)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-prepend pure t side-effect-free] 5)
#@42 Concatenate S and SUFFIX.

(fn SUFFIX S)\1f
(defalias 's-append #[514 "\211\ 2P\207" [] 4 (#$ . 4239)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-append pure t side-effect-free] 5)
#@103 Splice NEEDLE into S at position N.
0 is the beginning of the string, -1 is the end.

(fn NEEDLE N S)\1f
(defalias 's-splice #[771 "\ 1\300W\203\19\0\211\300\ 3T\ 3G\\O\301\302\ 4Z\ 3\"\ 1\ 5\ 2Q\207\303\ 2\ 2\"\ 1\ 3\ 3GO\ 1\ 5\ 2Q\207" [0 s-right -1 s-left] 8 (#$ . 4452)])
#@52 Make a string of S repeated NUM times.

(fn NUM S)\1f
(defalias 's-repeat #[514 "\300\ 2\301V\203\13\0\ 1\ 1B\262\ 1\ 2S\262\ 3\202\ 1\0\302\303\ 2\"\207" [nil 0 apply concat] 6 (#$ . 4696)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-repeat pure t side-effect-free] 5)
#@52 Remove SUFFIX if it is at end of S.

(fn SUFFIX S)\1f
(defalias 's-chop-suffix #[514 "\ 1G[\ 1G\ 3GY\203\19\0\ 2\ 2\ 2\300O\230\203\19\0\ 1\301\ 2O\207\ 1\207" [nil 0] 7 (#$ . 4978)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-chop-suffix pure t side-effect-free] 5)
#@84 Remove SUFFIXES one by one in order, if they are at the end of S.

(fn SUFFIXES S)\1f
(defalias 's-chop-suffixes #[514 "\ 1\203\12\0\300\ 2@\ 2\"\262\ 1\ 1A\262\ 2\202\0\0\207" [s-chop-suffix] 5 (#$ . 5253)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-chop-suffixes pure t side-effect-free] 5)
#@58 Remove PREFIX if it is at the start of S.

(fn PREFIX S)\1f
(defalias 's-chop-prefix #[514 "\ 1G\ 1G\ 3GY\203\18\0\ 2\ 2\300\ 3O\230\203\18\0\ 1\ 1\301O\207\ 1\207" [0 nil] 7 (#$ . 5562)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-chop-prefix pure t side-effect-free] 5)
#@86 Remove PREFIXES one by one in order, if they are at the start of S.

(fn PREFIXES S)\1f
(defalias 's-chop-prefixes #[514 "\ 1\203\12\0\300\ 2@\ 2\"\262\ 1\ 1A\262\ 2\202\0\0\207" [s-chop-prefix] 5 (#$ . 5842)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-chop-prefixes pure t side-effect-free] 5)
#@66 Returns the longest prefix S1 and S2 have in common.

(fn S1 S2)\1f
(defalias 's-shared-start #[514 "\300\ 2\301\ 4G\ 4\301\ 6\ 6G&\ 6\211\302=\203\14\0\ 2\207\ 2\301\303\ 3!SO\207" [compare-strings 0 t abs] 9 (#$ . 6153)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-shared-start pure t side-effect-free] 5)
#@66 Returns the longest suffix S1 and S2 have in common.

(fn S1 S2)\1f
(defalias 's-shared-end #[514 "\ 1G\ 1G\ 1\ 1^\300\211\ 2W\203%\0\ 5\ 4\ 2ZSH\ 5\ 4\ 3ZSHU\203%\0\211T\262\ 1\202\b\0\211\300U\203-\0\301\207\ 5\ 1[\302O\207" [0 "" nil] 10 (#$ . 6472)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-shared-end pure t side-effect-free] 5)
#@58 Remove one trailing `\n`, `\r` or `\r\n` from S.

(fn S)\1f
(defalias 's-chomp #[257 "\300\301\ 2\"\207" [s-chop-suffixes ("\n" "\r")] 4 (#$ . 6808)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-chomp pure t side-effect-free] 5)
#@223 If S is longer than LEN, cut it down and add ELLIPSIS to the end.

The resulting string, including ellipsis, will be LEN characters
long.

When not specified, ELLIPSIS defaults to ‘...’.

(fn LEN S &optional ELLIPSIS)\1f
(defalias 's-truncate #[770 "\211\204\a\0\300\262\ 1\ 1G\ 3V\203\e\0\301\302\ 3\303\ 6\ 6\ 5GZO\ 3#\207\ 1\207" ["..." format "%s%s" 0] 9 (#$ . 7066)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-truncate pure t side-effect-free] 5)
#@68 If S is longer than LEN, wrap the words with newlines.

(fn LEN S)\1f
(defalias 's-word-wrap #[514 "\301 \302\303\ 2\"\216\304\305\306\"r\211q\210\302\307\ 2\"\216\ 2c\210\ 3\18\310ed\"\210)ed{*\262\ 1)\207" [fill-column match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] generate-new-buffer " *temp*" t #[0 "\301\300!\205	\0\302\300!\207" [V0 buffer-name kill-buffer] 2] fill-region] 7 (#$ . 7533)])
(byte-code "\300\301\302\303#\300\207" [function-put s-word-wrap side-effect-free t] 4)
#@77 If S is shorter than LEN, pad it with spaces so it is centered.

(fn LEN S)\1f
(defalias 's-center #[514 "\300\ 2\ 2GZ]\301\302\ 2\303\"\304\"\ 2\301\305\ 4\303\"\304\"Q\207" [0 make-string ceiling 2 32 floor] 9 (#$ . 8043)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-center pure t side-effect-free] 5)
#@80 If S is shorter than LEN, pad it with PADDING on the left.

(fn LEN PADDING S)\1f
(defalias 's-pad-left #[771 "\300\ 3\ 2GZ]\301\ 1\302\ 5!\"\ 2P\207" [0 make-string string-to-char] 8 (#$ . 8369)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-pad-left pure t side-effect-free] 5)
#@81 If S is shorter than LEN, pad it with PADDING on the right.

(fn LEN PADDING S)\1f
(defalias 's-pad-right #[771 "\300\ 3\ 2GZ]\ 1\301\ 2\302\ 6\ 6!\"P\207" [0 make-string string-to-char] 9 (#$ . 8669)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-pad-right pure t side-effect-free] 5)
#@53 Returns up to the LEN first chars of S.

(fn LEN S)\1f
(defalias 's-left #[514 "\211G\ 2V\203\f\0\211\300\ 3O\207\207" [0] 5 (#$ . 8973)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-left pure t side-effect-free] 5)
#@52 Returns up to the LEN last chars of S.

(fn LEN S)\1f
(defalias 's-right #[514 "\211G\211\ 3V\203\ f\0\ 1\ 1\ 4Z\ 2O\207\ 1\207" [] 6 (#$ . 9215)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-right pure t side-effect-free] 5)
#@48 Remove the first LEN chars from S.

(fn LEN S)\1f
(defalias 's-chop-left #[514 "\211G\211\ 3V\203\r\0\ 1\ 3\ 2O\207\300\207" [""] 6 (#$ . 9457)])
#@47 Remove the last LEN chars from S.

(fn LEN S)\1f
(defalias 's-chop-right #[514 "\211G\211\ 3V\203\ f\0\ 1\300\ 2\ 5ZO\207\301\207" [0 ""] 7 (#$ . 9596)])
#@179 Does S end with SUFFIX?

If IGNORE-CASE is non-nil, the comparison is done without paying
attention to case differences.

Alias: `s-suffix?'

(fn SUFFIX S &optional IGNORE-CASE)\1f
(defalias 's-ends-with\? #[770 "\ 1G\ 3GZ\211\300Y\205\19\0\301\ 4\302\211\ 6\ 6\ 5\302\ 6\b&\a\303=\207" [0 compare-strings nil t] 12 (#$ . 9743)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-ends-with\? pure t side-effect-free] 5)
#@246 Does S start with PREFIX?

If IGNORE-CASE is non-nil, the comparison is done without paying
attention to case differences.

Alias: `s-prefix?'. This is a simple wrapper around the built-in
`string-prefix-p'.

(fn PREFIX S &optional IGNORE-CASE)\1f
(defalias 's-starts-with\? #[770 "\300\ 3\ 3\ 3#\207" [string-prefix-p] 7 (#$ . 10170)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-starts-with\? pure t side-effect-free] 5)
#@12 

(fn VAL)\1f
(defalias 's--truthy\? #[257 "\211??\207" [] 2 (#$ . 10618)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s--truthy\? pure t side-effect-free] 5)
#@158 Does S contain NEEDLE?

If IGNORE-CASE is non-nil, the comparison is done without paying
attention to case differences.

(fn NEEDLE S &optional IGNORE-CASE)\1f
(defalias 's-contains\? #[770 "\211\18\302\303\ 4!\ 3\304\305\19\306\ 3\ 3\ 3#)\266\203!)\207" [case-fold-search inhibit-changing-match-data s--truthy\? regexp-quote nil t string-match] 11 (#$ . 10808)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-contains\? pure t side-effect-free] 5)
#@94 Is S1 equal to S2?

This is a simple wrapper around the built-in `string-equal'.

(fn S1 S2)\1f
(defalias 's-equals\? #[514 "\ 1\ 1\230\207" [] 4 (#$ . 11272)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-equals\? pure t side-effect-free] 5)
#@95 Is S1 less than S2?

This is a simple wrapper around the built-in `string-lessp'.

(fn S1 S2)\1f
(defalias 's-less\? #[514 "\ 1\ 1\231\207" [] 4 (#$ . 11541)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-less\? pure t side-effect-free] 5)
#@170 Does REGEXP match S?
If START is non-nil the search starts at that index.

This is a simple wrapper around the built-in `string-match-p'.

(fn REGEXP S &optional START)\1f
(defalias 's-matches\? #[770 "\301\ 3\ 3\ 3\302\18\303\ 3\ 3\ 3#)\266\203!\207" [inhibit-changing-match-data s--truthy\? t string-match] 11 (#$ . 11808)])
(byte-code "\300\301\302\303#\300\207" [function-put s-matches\? side-effect-free t] 4)
#@39 Is S nil or the empty string?

(fn S)\1f
(defalias 's-blank\? #[257 "\211?\206\b\0\211\300\230\207" [""] 3 (#$ . 12212)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-blank\? pure t side-effect-free] 5)
#@74 Is S nil or the empty string or string only contains whitespace?

(fn S)\1f
(defalias 's-blank-str\? #[257 "\300\ 1!\206\v\0\300\301\ 2!!\207" [s-blank\? s-trim] 4 (#$ . 12443)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-blank-str\? pure t side-effect-free] 5)
#@52 Is S anything but nil or the empty string?

(fn S)\1f
(defalias 's-present\? #[257 "\300\ 1!?\207" [s-blank\?] 3 (#$ . 12731)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-present\? pure t side-effect-free] 5)
#@62 Return S if it's `s-present?', otherwise return nil.

(fn S)\1f
(defalias 's-presence #[257 "\300\ 1!\205\a\0\211\207" [s-present\?] 3 (#$ . 12970)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-presence pure t side-effect-free] 5)
#@49 Are all the letters in S in lower case?

(fn S)\1f
(defalias 's-lowercase\? #[257 "\302\18\303\ 1\302\304\19\305\ 3\ 3\ 3#)\266\203)?\207" [case-fold-search inhibit-changing-match-data nil "[[:upper:]]" t string-match] 8 (#$ . 13228)])
(byte-code "\300\301\302\303#\300\207" [function-put s-lowercase\? side-effect-free t] 4)
#@49 Are all the letters in S in upper case?

(fn S)\1f
(defalias 's-uppercase\? #[257 "\302\18\303\ 1\302\304\19\305\ 3\ 3\ 3#)\266\203)?\207" [case-fold-search inhibit-changing-match-data nil "[[:lower:]]" t string-match] 8 (#$ . 13545)])
(byte-code "\300\301\302\303#\300\207" [function-put s-uppercase\? side-effect-free t] 4)
#@64 Are there both lower case and upper case letters in S?

(fn S)\1f
(defalias 's-mixedcase\? #[257 "\302\18\303\304\ 2\302\305\19\306\ 3\ 3\ 3#)\266\203\205 \0\307\ 2\302\305\19\306\ 3\ 3\ 3#)\266\203!)\207" [case-fold-search inhibit-changing-match-data nil s--truthy\? "[[:lower:]]" t string-match "[[:upper:]]"] 9 (#$ . 13862)])
#@81 In S, is the first letter upper case, and all other letters lower case?

(fn S)\1f
(defalias 's-capitalized\? #[257 "\302\18\303\304\ 2\302\305\19\306\ 3\ 3\ 3#)\266\203!)\207" [case-fold-search inhibit-changing-match-data nil s--truthy\? "^[[:upper:]][^[:upper:]]*$" t string-match] 9 (#$ . 14171)])
(byte-code "\300\301\302\303#\300\207" [function-put s-capitalized\? side-effect-free t] 4)
#@24 Is S a number?

(fn S)\1f
(defalias 's-numeric\? #[257 "\301\302\ 2\303\304\18\305\ 3\ 3\ 3#)\266\203!\207" [inhibit-changing-match-data s--truthy\? "^[0-9]+$" nil t string-match] 9 (#$ . 14555)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-numeric\? pure t side-effect-free] 5)
#@45 Replaces OLD with NEW in S.

(fn OLD NEW S)\1f
(defalias 's-replace #[771 "\300\301\ 4!\ 3\ 3\302\211%\207" [replace-regexp-in-string regexp-quote t] 9 (#$ . 14855)])
(byte-code "\300\301\302\303#\300\301\304\303#\305\306\307\"\207" [function-put s-replace pure t side-effect-free defalias s-replace-regexp replace-regexp-in-string] 5)
#@48 Get the value of KEY in ALIST.

(fn ALIST KEY)\1f
(defalias 's--aget #[514 "\300\ 1\ 3\"A\207" [assoc-string] 5 (#$ . 15188)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s--aget pure t side-effect-free] 5)
#@100 REPLACEMENTS is a list of cons-cells. Each `car` is replaced with `cdr` in S.

(fn REPLACEMENTS S)\1f
(defalias 's-replace-all #[514 "\301\18\302\303\304\305\ 5\"!\306\307\ 5\"\ 3\310\211%)\207" [case-fold-search nil replace-regexp-in-string regexp-opt mapcar car make-closure #[257 "\301\300\ 2\"\207" [V0 s--aget] 4 "\n\n(fn IT)"] t] 8 (#$ . 15421)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-replace-all pure t side-effect-free] 5)
#@92 Convert S to lower case.

This is a simple wrapper around the built-in `downcase'.

(fn S)\1f
(defalias 's-downcase #[257 "\211\227\207" [] 2 (#$ . 15879)])
(byte-code "\300\301\302\303#\300\207" [function-put s-downcase side-effect-free t] 4)
#@90 Convert S to upper case.

This is a simple wrapper around the built-in `upcase'.

(fn S)\1f
(defalias 's-upcase #[257 "\211\226\207" [] 2 (#$ . 16126)])
(byte-code "\300\301\302\303#\300\207" [function-put s-upcase side-effect-free t] 4)
#@85 Convert S first word's first character to upper and the rest to lower case.

(fn S)\1f
(defalias 's-capitalize #[257 "\211\300\301O\226\ 1\301\302O\227P\207" [0 1 nil] 5 (#$ . 16367)])
(byte-code "\300\301\302\303#\300\207" [function-put s-capitalize side-effect-free t] 4)
#@147 Convert in S each word's first character to upper and the rest to lower case.

This is a simple wrapper around the built-in `capitalize'.

(fn S)\1f
(defalias 's-titleize #[257 "\300\ 1!\207" [capitalize] 3 (#$ . 16643)])
(byte-code "\300\301\302\303#\300\207" [function-put s-titleize side-effect-free t] 4)
#@235 Threads S through the forms. Inserts S as the last item
in the first form, making a list of it if it is not a list
already. If there are more forms, inserts the first form as the
last item in second form, etc.

(fn S FORM &rest MORE)\1f
(defalias 's-with '(macro . #[642 "\211\204\17\0\ 1<\203\13\0\ 1@\300\ 3A\ 5C\"B\207\ 1\ 3D\207\301\211\ 4\ 4E\ 2BB\207" [append s-with] 7 (#$ . 16954)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put s-with edebug-form-spec (form &rest [&or (function &rest form) fboundp]) lisp-indent-function 1] 4)
#@179 Returns first index of NEEDLE in S, or nil.

If IGNORE-CASE is non-nil, the comparison is done without paying
attention to case differences.

(fn NEEDLE S &optional IGNORE-CASE)\1f
(defalias 's-index-of #[770 "\211\18\302\ 3!\ 2\303\304\19\305\ 3\ 3\ 3#)\266\203)\207" [case-fold-search inhibit-changing-match-data regexp-quote nil t string-match] 10 (#$ . 17487)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-index-of pure t side-effect-free] 5)
#@34 Return the reverse of S.

(fn S)\1f
(defalias 's-reverse #[257 "\301 \302\303\ 2\"\216\304\ 2!\203J\0\ 1\305\ 1\306\"\262\ 1\306\307\310!\210\ 1\203B\0\ 1\211A\262\ 3\242C\311\ 3@\b\"\2039\0\ 2\211A\262\ 4\242\ 1B\262\ 1\202$\0\211\237\ 2\244\266\202\202\19\0\211\260\ 1\266\202\202T\0\ 1\305\ 1\306\"\262\ 1\237\260\ 1)\207" [ucs-normalize-combining-chars match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] multibyte-string-p append nil require ucs-normalize memql] 8 (#$ . 17951)])
(byte-code "\300\301\302\303#\300\301\304\303#\300\207" [function-put s-reverse pure t side-effect-free] 5)
#@203 Return a list of matches for REGEX in STRING.

Each element itself is a list of matches, as per
`match-string'. Multiple matches at the same position will be
ignored after the first.

(fn REGEX STRING)\1f
(defalias 's-match-strings-all #[514 "\300 \301\302\ 2\"\216\303\304\211\ 4GW\203E\0\305\ 5\ 5\ 3#\203E\0\304\224T\262\ 1\303\300 G\306\245\304\211\ 2U\204:\0\307\ 1\ 6\b\"\ 3B\262\ 3\211T\262\ 1\202$\0\ 2\237\ 5B\262\ 5\266\ 3\202	\0\ 1\237\266\202)\207" [match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] nil 0 string-match 2 match-string] 11 (#$ . 18531)])
(byte-code "\300\301\302\303#\300\207" [function-put s-match-strings-all side-effect-free t] 4)
#@131 Return a list of matched positions for REGEXP in STRING.
SUBEXP-DEPTH is 0 by default.

(fn REGEXP STRING &optional SUBEXP-DEPTH)\1f
(defalias 's-matched-positions-all #[770 "\211\204\a\0\300\262\ 1\301 \302\303\ 2\"\216\300\304\305\ 6\ 6\ 6\ 6\ 4#\2031\0\ 1\ 5GW\2031\0\ 3\224\ 4\225B\ 1B\262\ 1\300\225\262\ 2\202\10\0\211\237\266\202)\207" [0 match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] nil string-match] 10 (#$ . 19188)])
(byte-code "\300\301\302\303#\300\207" [function-put s-matched-positions-all side-effect-free t] 4)
#@583 When the given expression matches the string, this function returns a list
of the whole matching string and a string for each matched subexpressions.
Subexpressions that didn't match are represented by nil elements
in the list, except that non-matching subexpressions at the end
of REGEXP might not appear at all in the list.  That is, the
returned list can be shorter than the number of subexpressions in
REGEXP plus one.  If REGEXP did not match the returned value is
an empty list (nil).

When START is non-nil the search will start at that index.

(fn REGEXP S &optional START)\1f
(defalias 's-match #[770 "\300 \301\302\ 2\"\216\303\ 4\ 4\ 4#\205;\0\300 \304\ 1\2037\0\ 1@\ 2A@\ 1\205(\0\211\205(\0\ 6\ 6\ 2\ 2O\211\ 4B\262\ 4\ 4AA\262\ 5\266\ 3\202\12\0\211\237\266\202)\207" [match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] string-match nil] 11 (#$ . 19721)])
(byte-code "\300\301\302\303#\300\207" [function-put s-match side-effect-free t] 4)
#@60 Slices S up at every index matching REGEXP.

(fn REGEXP S)\1f
(defalias 's-slice-at #[514 "\300\ 1!\203	\0\211C\207\301\300\ 2!\204@\0\302 \303\304\ 2\"\216\305\ 4\ 4\306#\211\2032\0\ 3\307\ 2O\ 3B\262\ 3\ 3\ 1\301O\262\ 4\210\202;\0\ 3\ 3B\262\ 3\310\262\ 4\210)\210\202\n\0\211\237\207" [s-blank\? nil match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] string-match 1 0 ""] 8 (#$ . 20668)])
(byte-code "\300\301\302\303#\300\207" [function-put s-slice-at side-effect-free t] 4)
#@37 Split S into list of words.

(fn S)\1f
(defalias 's-split-words #[257 "\301\302\303\18\304\305\306\304\307\306\ 6\b##)\310#\207" [case-fold-search s-split "[^[:word:]0-9]+" nil replace-regexp-in-string "\\([[:lower:]]\\)\\([[:upper:]]\\)" "\\1 \\2" "\\([[:upper:]]\\)\\([[:upper:]][0-9[:lower:]]\\)" t] 10 (#$ . 21145)])
(byte-code "\300\301\302\303#\300\207" [function-put s-split-words side-effect-free t] 4)
#@96 Like MAPCAR, but applies a different function to the first element.

(fn FN-HEAD FN-REST LIST)\1f
(defalias 's--mapcar-head #[771 "\211\205\ e\0\ 2\ 1@!\300\ 3\ 3A\"B\207" [mapcar] 7 (#$ . 21554)])
#@38 Convert S to lowerCamelCase.

(fn S)\1f
(defalias 's-lower-camel-case #[257 "\300\301\302\303\304\305\ 6\ 6!#\"\207" [s-join "" s--mapcar-head downcase capitalize s-split-words] 8 (#$ . 21744)])
(byte-code "\300\301\302\303#\300\207" [function-put s-lower-camel-case side-effect-free t] 4)
#@38 Convert S to UpperCamelCase.

(fn S)\1f
(defalias 's-upper-camel-case #[257 "\300\301\302\303\304\ 5!\"\"\207" [s-join "" mapcar capitalize s-split-words] 7 (#$ . 22033)])
(byte-code "\300\301\302\303#\300\207" [function-put s-upper-camel-case side-effect-free t] 4)
#@34 Convert S to snake_case.

(fn S)\1f
(defalias 's-snake-case #[257 "\300\301\302\303\304\ 5!\"\"\207" [s-join "_" mapcar downcase s-split-words] 7 (#$ . 22301)])
(byte-code "\300\301\302\303#\300\207" [function-put s-snake-case side-effect-free t] 4)
#@36 Convert S to dashed-words.

(fn S)\1f
(defalias 's-dashed-words #[257 "\300\301\302\303\304\ 5!\"\"\207" [s-join "-" mapcar downcase s-split-words] 7 (#$ . 22552)])
(byte-code "\300\301\302\303#\300\207" [function-put s-dashed-words side-effect-free t] 4)
#@36 Convert S to spaced words.

(fn S)\1f
(defalias 's-spaced-words #[257 "\300\301\302\ 3!\"\207" [s-join " " s-split-words] 5 (#$ . 22809)])
(byte-code "\300\301\302\303#\300\207" [function-put s-spaced-words side-effect-free t] 4)
#@41 Convert S to Capitalized words.

(fn S)\1f
(defalias 's-capitalized-words #[257 "\300\ 1!\301\302\303\ 3@!\304\305\ 5A\"B\"\207" [s-split-words s-join " " capitalize mapcar downcase] 8 (#$ . 23040)])
(byte-code "\300\301\302\303#\300\207" [function-put s-capitalized-words side-effect-free t] 4)
#@39 Convert S to Titleized Words.

(fn S)\1f
(defalias 's-titleized-words #[257 "\300\301\302\303\304\ 5!\"\"\207" [s-join " " mapcar s-titleize s-split-words] 7 (#$ . 23333)])
(byte-code "\300\301\302\303#\300\207" [function-put s-titleized-words side-effect-free t] 4)
#@36 Convert S to its initials.

(fn S)\1f
(defalias 's-word-initials #[257 "\300\301\302\303\304\ 5!\"\"\207" [s-join "" mapcar #[257 "\211\300\301O\207" [0 1] 4 "\n\n(fn SS)"] s-split-words] 7 (#$ . 23601)])
(byte-code "\300\301\302\303#\304\305\306\307#\210\304\305\310\311#\207" [function-put s-word-initials side-effect-free t put s-format-resolve error-conditions (error s-format s-format-resolve) error-message "Cannot resolve a template to values"] 5)
#@504 Format TEMPLATE with the function REPLACER.

REPLACER takes an argument of the format variable and optionally
an extra argument which is the EXTRA value from the call to
`s-format'.

Several standard `s-format' helper functions are recognized and
adapted for this:

    (s-format "${name}" \='gethash hash-table)
    (s-format "${name}" \='aget alist)
    (s-format "$0" \='elt sequence)

The REPLACER function may be used to do any other kind of
transformation.

(fn TEMPLATE REPLACER &optional EXTRA)\1f
(defalias 's-format #[770 "\300 \301\302\ 2\"\216\303\304\301\305\ 6\ 6\ 6\ 6\ 6\ 6$\ 6\ 6\306\211%)\207" [match-data make-closure #[0 "\301\300!\207" [V0 set-match-data] 2] replace-regexp-in-string "\\$\\({\\([^}]+\\)}\\|[0-9]+\\)" #[257 "\303\304\ 2\"\211\203\f\0\211\202\12\0\305\303\306\ 4\"!\262\ 1\307 \310\311\ 2\"\216\300\312=\203(\0\300\ 2\301\"\202c\0\300\313=\2035\0\314\301\ 3\"\202c\0\300\315=\203B\0\300\301\ 3\"\202c\0\300\316=\203Q\0\317\301\320\ 4!\"\202c\0\321\302!\210\301\203`\0\300\ 2\301\"\202c\0\300\ 2!\211\203n\0\322\323\ 2\"\202r\0\324\325\ 5\"\262\ 1)\207" [V0 V1 V2 match-string 2 string-to-number 1 match-data make-closure #[0 "\301\300!\207" [V0 set-match-data] 2] gethash aget s--aget elt oref slot-value intern set-match-data format "%s" signal s-format-resolve] 7 "\n\n(fn MD)"] t] 11 (#$ . 24058)])
#@92 If `t' interpolate lisp values as lisp.

`s-lex-format' inserts values with (format "%S").\1f
(defvar s-lex-value-as-lisp nil (#$ . 25340))
#@33 Expand FMT into lisp.

(fn FMT)\1f
(defalias 's-lex-fmt|expand #[257 "\300\ 1\301\302\303\304\305\306\307\ 6	\"\"\"F\207" [s-format 'aget append (list) mapcar #[257 "\300\ 1A@\301\302\303\ 5A@!EE\207" [cons format (if s-lex-value-as-lisp "%S" "%s") intern] 7 "\n\n(fn MATCHES)"] s-match-strings-all "${\\([^}]+\\)}"] 11 (#$ . 25483)])
(byte-code "\300\301\302\303#\300\207" [function-put s-lex-fmt|expand side-effect-free t] 4)
#@333 `s-format` with the current environment.

FORMAT-STR may use the `s-format' variable reference to refer to
any variable:

 (let ((x 1))
   (s-lex-format "x is: ${x}"))

The values of the variables are interpolated with "%s" unless
the variable `s-lex-value-as-lisp' is `t' and then they are
interpolated with "%S".

(fn FORMAT-STR)\1f
(defalias 's-lex-format '(macro . #[257 "\300\ 1!\207" [s-lex-fmt|expand] 3 (#$ . 25907)]))
(put 's-lex-format 'edebug-form-spec '(form))
#@452 Count occurrences of `regexp' in `s'.

`start', inclusive, and `end', exclusive, delimit the part of `s' to
match.  `start' and `end' are both indexed starting at 1; the initial
character in `s' is index 1.

This function starts looking for the next match from the end of the
previous match.  Hence, it ignores matches that overlap a previously
found match.  To count overlapping matches, use
`s-count-matches-all'.

(fn REGEXP S &optional START END)\1f
(defalias 's-count-matches #[1026 "\300 \301\302\ 2\"\216\303\304\305\"r\211q\210\301\306\ 2\"\216\ 4c\210eb\210\307\ 6\ 6\ 5\206\"\0\310\ 5\206'\0d#*\262\ 1)\207" [match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] generate-new-buffer " *temp*" t #[0 "\301\300!\205	\0\302\300!\207" [V0 buffer-name kill-buffer] 2] count-matches 1] 10 (#$ . 26382)])
(byte-code "\300\301\302\303#\300\207" [function-put s-count-matches side-effect-free t] 4)
#@487 Count occurrences of `regexp' in `s'.

`start', inclusive, and `end', exclusive, delimit the part of `s' to
match.  `start' and `end' are both indexed starting at 1; the initial
character in `s' is index 1.

This function starts looking for the next match from the second
character of the previous match.  Hence, it counts matches that
overlap a previously found match.  To ignore matches that overlap a
previously found match, use `s-count-matches'.

(fn REGEXP S &optional START END)\1f
(defalias 's-count-matches-all #[1026 "\300\301\ 5\"\302\211\ 5\ 5\203\10\0\ 5S\202\11\0\302\ 5\205\17\0\ 5SO\303 \304\305\ 2\"\216\ 2\ 2GW\203;\0\306\ 5\ 3\ 5\307O\"\2034\0\ 3T\262\ 4\ 2T\262\ 3\202\1f\0)\210\ 2\207" [format "^%s" 0 match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] s-matches\? nil] 14 (#$ . 27295)])
(byte-code "\300\301\302\303#\300\207" [function-put s-count-matches-all side-effect-free t] 4)
#@213 Wrap string S with PREFIX and optionally SUFFIX.

Return string S with PREFIX prepended.  If SUFFIX is present, it
is appended, otherwise PREFIX is used as both prefix and
suffix.

(fn S PREFIX &optional SUFFIX)\1f
(defalias 's-wrap #[770 "\ 1\ 3\ 2\206\a\0\ 3Q\207" [] 6 (#$ . 28187)])
(byte-code "\300\301\302\303#\300\301\304\303#\305\306\307\"\210\305\310\311\"\210\305\312\313\"\210\305\314\315\"\210\305\316\317\"\210\305\320\321\"\210\305\322\323\"\210\305\324\325\"\210\305\326\327\"\210\305\330\331\"\210\305\332\333\"\210\305\334\335\"\210\305\336\335\"\210\305\337\340\"\210\305\341\335\"\210\305\342\317\"\210\305\343\317\"\210\305\344\345\"\210\346\347!\207" [function-put s-wrap pure t side-effect-free defalias s-blank-p s-blank\? s-blank-str-p s-blank-str\? s-capitalized-p s-capitalized\? s-contains-p s-contains\? s-ends-with-p s-ends-with\? s-equals-p s-equals\? s-less-p s-less\? s-lowercase-p s-lowercase\? s-matches-p s-matches\? s-mixedcase-p s-mixedcase\? s-numeric-p s-numeric\? s-prefix-p s-starts-with\? s-prefix\? s-present-p s-present\? s-starts-with-p s-suffix-p s-suffix\? s-uppercase-p s-uppercase\? provide s] 5)