;ELC ;;; Compiled by daniel@waffles on Sun Jul 20 16:05:13 2014 ;;; from file /Users/daniel/.emacs.d/elpa/s-20140714.707/s.el ;;; in Emacs version 24.3.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. ;;; This file does not contain utf-8 non-ASCII characters, ;;; and so can be loaded in Emacs versions earlier than 23. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (require 'ucs-normalize) #@42 Remove whitespace at the beginning of S. (defalias 's-trim-left #[(s) "\301\302\"\203\303\304\305\211$\207\207" [s string-match "\\`[ \n ]+" replace-match "" t] 5 (#$ . 543)]) #@36 Remove whitespace at the end of S. (defalias 's-trim-right #[(s) "\301\302\"\203\303\304\305\211$\207\207" [s string-match "[ \n ]+\\'" replace-match "" t] 5 (#$ . 731)]) #@50 Remove whitespace at the beginning and end of S. (defalias 's-trim #[(s) "\301\302!!\207" [s s-trim-left s-trim-right] 3 (#$ . 914)]) #@63 Convert all adjacent whitespace characters to a single space. (defalias 's-collapse-whitespace #[(s) "\301\302\303#\207" [s replace-regexp-in-string "[ \n ]+" " "] 4 (#$ . 1055)]) #@190 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'. (defalias 's-split #[(separator s &optional omit-nulls) "\303 \n#\207" [s separator omit-nulls split-string] 4 (#$ . 1244)]) #@164 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'. (defalias 's-split-up-to #[(separator s n &optional omit-nulls) "\306 \307\216\310\311\312\313!r q\210\314\216\fc\210eb\315 \311\316#\203M\310W\203M\317\n\310\224\"\203;\320\232\204@ B)\310\225bS\202`dU\204]\317\nd\" B\202f\204f\320 B+ \237,\207" [save-match-data-internal r op #1=#:temp-buffer s separator match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) 0 nil generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) re-search-forward t buffer-substring-no-properties "" n sub omit-nulls] 4 (#$ . 1566)]) #@56 Splits S into a list of strings on newline characters. (defalias 's-lines #[(s) "\301\302\"\207" [s s-split "\\( \n\\|[\n ]\\)"] 3 (#$ . 2377)]) #@60 Join all the strings in STRINGS with SEPARATOR in between. (defalias 's-join #[(separator strings) "\302\303 #\207" [strings separator mapconcat identity] 4 (#$ . 2529)]) #@48 Join all the string arguments into one string. (defalias 's-concat #[(&rest strings) "\301\302\"\207" [strings apply concat] 3 (#$ . 2707)]) #@27 Concatenate PREFIX and S. (defalias 's-prepend #[(prefix s) " P\207" [prefix s] 2 (#$ . 2855)]) #@27 Concatenate S and SUFFIX. (defalias 's-append #[(suffix s) " P\207" [s suffix] 2 (#$ . 2958)]) #@40 Make a string of S repeated NUM times. (defalias 's-repeat #[(num s) "\303 \304V\203\nB S\211\202\305\306\")\207" [ss num s nil 0 apply concat] 4 (#$ . 3060)]) #@37 Remove SUFFIX if it is at end of S. (defalias 's-chop-suffix #[(suffix s) "G[\nGGY\203\n \303O\230\203\n\304 O\202\n)\207" [suffix pos s nil 0] 4 (#$ . 3235)]) #@67 Remove SUFFIXES one by one in order, if they are at the end of S. (defalias 's-chop-suffixes #[(suffixes s) "\203\302@ \"A\211\204 \207" [suffixes s s-chop-suffix] 4 (#$ . 3411)]) #@43 Remove PREFIX if it is at the start of S. (defalias 's-chop-prefix #[(prefix s) "G\nGGY\203\n\303 O\230\203\n \304O\202\n)\207" [prefix pos s 0 nil] 4 (#$ . 3606)]) #@69 Remove PREFIXES one by one in order, if they are at the start of S. (defalias 's-chop-prefixes #[(prefixes s) "\203\302@ \"A\211\204 \207" [prefixes s s-chop-prefix] 4 (#$ . 3787)]) #@54 Returns the longest prefix S1 and S2 have in common. (defalias 's-shared-start #[(s1 s2) "G G^\304\n W\203\nH \nHU\203\nT\211\202 \304\nO*\207" [s1 s2 i search-length 0] 4 (#$ . 3984)]) #@54 Returns the longest suffix S1 and S2 have in common. (defalias 's-shared-end #[(s1 s2) "G\nG ^\306\211\fW\203+\307 \310#H\n\307 \310#HU\203+ T\211\202 \311 !\2035\312\202: [\313O,\207" [s1 l1 s2 l2 search-length i 0 - 1 zerop "" nil] 7 (#$ . 4187)]) #@50 Remove one trailing `\n`, `\r` or `\r\n` from S. (defalias 's-chomp #[(s) "\301\302\"\207" [s s-chop-suffixes ("\n" " ")] 3 (#$ . 4459)]) #@73 If S is longer than LEN, cut it down to LEN - 3 and add ... at the end. (defalias 's-truncate #[(len s) "G V\203\302\303\304 \305ZO\"\207\207" [s len format "%s..." 0 3] 6 (#$ . 4604)]) #@56 If S is longer than LEN, wrap the words with newlines. (defalias 's-word-wrap #[(len s) "\304\305!rq\210\306\216 c\210\n\307ed\"\210)\310ed\"+\207" [#1=#:temp-buffer s len fill-column generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) fill-region buffer-substring-no-properties] 3 (#$ . 4801)]) #@65 If S is shorter than LEN, pad it with spaces so it is centered. (defalias 's-center #[(len s) "\303 GZ]\304\305\n\306\"\307\" \304\310\n\306\"\307\"Q)\207" [len s extra 0 make-string ceiling 2 32 floor] 6 (#$ . 5164)]) #@60 If S is shorter than LEN, pad it with PADDING on the left. (defalias 's-pad-left #[(len padding s) "\304 GZ]\305\n\306 !\" P)\207" [len s extra padding 0 make-string string-to-char] 4 (#$ . 5391)]) #@61 If S is shorter than LEN, pad it with PADDING on the right. (defalias 's-pad-right #[(len padding s) "\304 GZ] \305\n\306 !\"P)\207" [len s extra padding 0 make-string string-to-char] 5 (#$ . 5597)]) #@41 Returns up to the LEN first chars of S. (defalias 's-left #[(len s) "G V\203\f\302 O\207\207" [s len 0] 3 (#$ . 5805)]) #@40 Returns up to the LEN last chars of S. (defalias 's-right #[(len s) "G\211\nV\203 \nZ O\202)\207" [s l len] 4 (#$ . 5935)]) #@142 Does S end with SUFFIX? If IGNORE-CASE is non-nil, the comparison is done without paying attention to case differences. Alias: `s-suffix?' (defalias 's-ends-with\? #[(suffix s &optional ignore-case) "G GZ\211\304Y\205\305 \306\211\n\306 &\307=)\207" [s suffix start-pos ignore-case 0 compare-strings nil t] 9 (#$ . 6074)]) (defalias 's-ends-with-p 's-ends-with\?) #@209 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'. (defalias 's-starts-with\? #[(prefix s &optional ignore-case) "\303 \n#\207" [prefix s ignore-case string-prefix-p] 4 (#$ . 6453)]) (byte-code "\300\301\302\"\210\300\303\304\"\210\300\305\302\"\210\300\306\304\"\210\300\307\302\"\207" [defalias s-starts-with-p s-starts-with\? s-suffix\? s-ends-with\? s-prefix\? s-suffix-p s-prefix-p] 3) (defalias 's--truthy\? #[(val) "??\207" [val] 1]) #@121 Does S contain NEEDLE? If IGNORE-CASE is non-nil, the comparison is done without paying attention to case differences. (defalias 's-contains\? #[(needle s &optional ignore-case) "\306\307\n! \310 \311\f\312 \f#,!)\207" [ignore-case case-fold-search needle s start string s--truthy\? regexp-quote nil t string-match regexp inhibit-changing-match-data] 5 (#$ . 7060)]) (defalias 's-contains-p 's-contains\?) #@82 Is S1 equal to S2? This is a simple wrapper around the built-in `string-equal'. (defalias 's-equals\? #[(s1 s2) " \230\207" [s1 s2] 2 (#$ . 7481)]) (defalias 's-equals-p 's-equals\?) #@83 Is S1 less than S2? This is a simple wrapper around the built-in `string-lessp'. (defalias 's-less\? #[(s1 s2) " \231\207" [s1 s2] 2 (#$ . 7672)]) (defalias 's-less-p 's-less\?) #@139 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'. (defalias 's-matches\? #[(regexp s &optional start) "\305 \n\306\307 \n#,!\207" [regexp s start string inhibit-changing-match-data s--truthy\? t string-match] 5 (#$ . 7859)]) (defalias 's-matches-p 's-matches\?) #@31 Is S nil or the empty string? (defalias 's-blank\? #[(s) "?\206\301\230\207" [s ""] 2 (#$ . 8221)]) #@44 Is S anything but nil or the empty string? (defalias 's-present\? #[(s) "\301!?\207" [s s-blank\?] 2 (#$ . 8331)]) #@54 Return S if it's `s-present?', otherwise return nil. (defalias 's-presence #[(s) "\301!\205\207" [s s-present\?] 2 (#$ . 8453)]) #@41 Are all the letters in S in lower case? (defalias 's-lowercase\? #[(s) "\306\307 \306\310\311\f \n#-?\207" [case-fold-search s start string regexp inhibit-changing-match-data nil "[[:upper:]]" t string-match] 4 (#$ . 8592)]) #@41 Are all the letters in S in upper case? (defalias 's-uppercase\? #[(s) "\306\307 \306\310\311\f \n#-?\207" [case-fold-search s start string regexp inhibit-changing-match-data nil "[[:lower:]]" t string-match] 4 (#$ . 8828)]) #@56 Are there both lower case and upper case letters in S? (defalias 's-mixedcase\? #[(s) "\306\307\310 \306\311\312\f \n#,\205\"\313 \306\311\312\f \n#,!)\207" [case-fold-search s start string regexp inhibit-changing-match-data nil s--truthy\? "[[:lower:]]" t string-match "[[:upper:]]"] 5 (#$ . 9064)]) #@73 In S, is the first letter upper case, and all other letters lower case? (defalias 's-capitalized\? #[(s) "\306\307\310 \306\311\312\f \n#,!)\207" [case-fold-search s start string regexp inhibit-changing-match-data nil s--truthy\? "^[[:upper:]][^[:upper:]]*$" t string-match] 5 (#$ . 9381)]) #@16 Is S a number? (defalias 's-numeric\? #[(s) "\305\306\307\310\311 \n #,!\207" [s start string regexp inhibit-changing-match-data s--truthy\? "^[0-9]+$" nil t string-match] 5 (#$ . 9683)]) #@29 Replaces OLD with NEW in S. (defalias 's-replace #[(old new s) "\303\304! \n\305\211%\207" [old new s replace-regexp-in-string regexp-quote t] 6 (#$ . 9882)]) (defalias 's--aget #[(alist key) "\302 \"A\207" [key alist assoc] 3]) #@79 REPLACEMENTS is a list of cons-cells. Each `car` is replaced with `cdr` in S. (defalias 's-replace-all #[(replacements s) "\302\303\304\305\"!\306 #\207" [replacements s replace-regexp-in-string regexp-opt mapcar car #[(it) "\302 \"\207" [replacements it s--aget] 3]] 5 (#$ . 10119)]) #@84 Convert S to lower case. This is a simple wrapper around the built-in `downcase'. (defalias 's-downcase #[(s) "\227\207" [s] 1 (#$ . 10412)]) #@82 Convert S to upper case. This is a simple wrapper around the built-in `upcase'. (defalias 's-upcase #[(s) "\226\207" [s] 1 (#$ . 10562)]) #@89 Convert the first word's first character to upper case and the rest to lower case in S. (defalias 's-capitalize #[(s) "\301\302O\226\302\303O\227P\207" [s 0 1 nil] 4 (#$ . 10708)]) #@144 Convert each word's first character to upper case and the rest to lower case in S. This is a simple wrapper around the built-in `capitalize'. (defalias 's-titleize #[(s) "\301!\207" [s capitalize] 2 (#$ . 10898)]) #@211 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. (defalias 's-with '(macro . #[(s form &rest more) "\204 <\203 @\303 A\nC\"B\207 \nD\207\304\211\n EBB\207" [more form s append s-with] 4 (#$ . 11121)])) (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) #@142 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. (defalias 's-index-of #[(needle s &optional ignore-case) "\306\n! \307\n\310 \311\n \f#-\207" [ignore-case case-fold-search needle s start string regexp-quote nil t string-match regexp inhibit-changing-match-data] 4 (#$ . 11658)]) #@26 Return the reverse of S. (defalias 's-reverse #[(s) "\306!\203<\307 \310\")\310 \2037 \211A@C\311 @ \"\203. \211A@\fB\202\f\237\n\244)\202\n\260*\207\307 \310\")\237\260\207" [s string output input grapheme ucs-normalize-combining-chars multibyte-string-p append nil memql] 3 (#$ . 12043)]) #@184 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. (defalias 's-match-strings-all #[(regex string) "\306\307\nGW\203B\310 \n#\203B\307\224T\306\311 G\312\245\307\f\f U\2048\313\f\n\"\fB\f\fT\211\202#\f\237 B+\202 \237*\207" [i all-strings string regex match num-matches nil 0 string-match match-data 2 match-string strings] 5 (#$ . 12362)]) #@274 When the given expression matches the string, this function returns a list of the whole matching string and a string for each matched subexpressions. If it did not match the returned value is an empty list (nil). When START is non-nil the search will start at that index. (defalias 's-match #[(regexp s &optional start) "\306 \307\216\310 \n #\205H\306 \311 \203E @\n \211 A@)\f\n\2053\f\2053\n\n\fO\211 \fB \211 AA)+\202\f\237**\207" [save-match-data-internal regexp s start result match-data-list match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match nil beg x end subs] 5 (#$ . 12861)]) #@45 Slices S up at every index matching REGEXP. (defalias 's-slice-at #[(regexp s) "\304 \305\216\306\307\n \310#\211\203 \311 O\312\n \306O\"B\202\" C+\207" [save-match-data-internal i regexp s match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) nil string-match 1 0 s-slice-at] 7 (#$ . 13534)]) #@29 Split S into list of words. (defalias 's-split-words #[(s) "\302\303\304\305\306\307\305\310\307 ##)\311#\207" [case-fold-search s s-split "[^[:word:]0-9]+" nil replace-regexp-in-string "\\([[:lower:]]\\)\\([[:upper:]]\\)" "\\1 \\2" "\\([[:upper:]]\\)\\([[:upper:]][0-9[:lower:]]\\)" t] 9 (#$ . 13885)]) #@69 Like MAPCAR, but applies a different function to the first element. (defalias 's--mapcar-head #[(fn-head fn-rest list) "\205 @!\303\nA\"B\207" [list fn-head fn-rest mapcar] 4 (#$ . 14196)]) #@30 Convert S to lowerCamelCase. (defalias 's-lower-camel-case #[(s) "\301\302\303\304\305\306!#\"\207" [s s-join "" s--mapcar-head downcase capitalize s-split-words] 7 (#$ . 14397)]) #@30 Convert S to UpperCamelCase. (defalias 's-upper-camel-case #[(s) "\301\302\303\304\305!\"\"\207" [s s-join "" mapcar capitalize s-split-words] 6 (#$ . 14584)]) #@26 Convert S to snake_case. (defalias 's-snake-case #[(s) "\301\302\303\304\305!\"\"\207" [s s-join "_" mapcar downcase s-split-words] 6 (#$ . 14751)]) #@28 Convert S to dashed-words. (defalias 's-dashed-words #[(s) "\301\302\303\304\305!\"\"\207" [s s-join "-" mapcar downcase s-split-words] 6 (#$ . 14907)]) #@33 Convert S to Capitalized words. (defalias 's-capitalized-words #[(s) "\302!\303\304\305 @!\306\307 A\"B\")\207" [s words s-split-words s-join " " capitalize mapcar downcase] 6 (#$ . 15067)]) #@31 Convert S to Titleized Words. (defalias 's-titleized-words #[(s) "\301\302\303\304\305!\"\"\207" [s s-join " " mapcar s-titleize s-split-words] 6 (#$ . 15266)]) #@28 Convert S to its initials. (defalias 's-word-initials #[(s) "\301\302\303\304\305!\"\"\207" [s s-join "" mapcar #[(ss) "\301\302O\207" [ss 0 1] 3] s-split-words] 6 (#$ . 15434)]) (byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put s-format-resolve error-conditions (error s-format s-format-resolve) error-message "Cannot resolve a template to values"] 4) #@458 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. (defalias 's-format #[(template replacer &optional extra) "\302 \303\216\304\305\306 \307\211%*\207" [saved-match-data template match-data ((set-match-data saved-match-data)) replace-regexp-in-string "\\$\\({\\([^}]+\\)}\\|[0-9]+\\)" #[(md) "\306\307\"\211\203 \202\310\306\311\"!)\312 \313\216\f\314=\203'\f \"\202T\f\315=\2034\316 \"\202T\f\317=\203A\f \"\202T\320!\210 \203Q\f \"\202T\f !\211\203_\202c\321\322\",\207" [md m replacer-match-data var replacer extra match-string 2 string-to-number 1 match-data ((set-match-data replacer-match-data)) gethash aget s--aget elt set-match-data signal s-format-resolve saved-match-data v] 5] t] 6 (#$ . 15807)]) #@92 If `t' interpolate lisp values as lisp. `s-lex-format' inserts values with (format "%S"). (defvar s-lex-value-as-lisp nil (#$ . 16959)) #@23 Expand FMT into lisp. (defalias 's-lex-fmt|expand #[(fmt) "\301\302\303\304\305\306\307\310\"\"\"F\207" [fmt s-format 'aget append (list) mapcar #[(matches) "\302\211A@)\303\304\305\211A@)!EE\207" [matches x cons format (if s-lex-value-as-lisp "%S" "%s") intern] 7] s-match-strings-all "${\\([^}]+\\)}"] 10 (#$ . 17102)]) #@316 `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". (defalias 's-lex-format '(macro . #[(format-str) "\301!\207" [format-str s-lex-fmt|expand] 2 (#$ . 17437)])) (put 's-lex-format 'edebug-form-spec '(form)) #@117 Count occurrences of `regexp' in `s'. `start', inclusive, and `end', exclusive, delimit the part of `s' to match.  (defalias 's-count-matches #[(regexp s &optional start end) "\305\306!rq\210\307\216 c\210eb\210\310\n \206\311\f\206d#+\207" [#1=#:temp-buffer s regexp start end generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) count-matches 1] 4 (#$ . 17915)]) (provide 's)