| // Compiled by ClojureScript 1.10.597 {:target :nodejs} |
| goog.provide('clojure.string'); |
| goog.require('cljs.core'); |
| goog.require('goog.string'); |
| goog.require('goog.string.StringBuffer'); |
| clojure.string.seq_reverse = (function clojure$string$seq_reverse(coll){ |
| return cljs.core.reduce.call(null,cljs.core.conj,cljs.core.List.EMPTY,coll); |
| }); |
| clojure.string.re_surrogate_pair = (new RegExp("([\\uD800-\\uDBFF])([\\uDC00-\\uDFFF])","g")); |
| /** |
| * Returns s with its characters reversed. |
| */ |
| clojure.string.reverse = (function clojure$string$reverse(s){ |
| return s.replace(clojure.string.re_surrogate_pair,"$2$1").split("").reverse().join(""); |
| }); |
| clojure.string.replace_all = (function clojure$string$replace_all(s,re,replacement){ |
| var r = (new RegExp(re.source,(function (){var G__6037 = "g"; |
| var G__6037__$1 = (cljs.core.truth_(re.ignoreCase)?[G__6037,"i"].join(''):G__6037); |
| var G__6037__$2 = (cljs.core.truth_(re.multiline)?[G__6037__$1,"m"].join(''):G__6037__$1); |
| if(cljs.core.truth_(re.unicode)){ |
| return [G__6037__$2,"u"].join(''); |
| } else { |
| return G__6037__$2; |
| } |
| })())); |
| return s.replace(r,replacement); |
| }); |
| clojure.string.replace_with = (function clojure$string$replace_with(f){ |
| return (function() { |
| var G__6038__delegate = function (args){ |
| var matches = cljs.core.drop_last.call(null,(2),args); |
| if(cljs.core._EQ_.call(null,cljs.core.count.call(null,matches),(1))){ |
| return f.call(null,cljs.core.first.call(null,matches)); |
| } else { |
| return f.call(null,cljs.core.vec.call(null,matches)); |
| } |
| }; |
| var G__6038 = function (var_args){ |
| var args = null; |
| if (arguments.length > 0) { |
| var G__6039__i = 0, G__6039__a = new Array(arguments.length - 0); |
| while (G__6039__i < G__6039__a.length) {G__6039__a[G__6039__i] = arguments[G__6039__i + 0]; ++G__6039__i;} |
| args = new cljs.core.IndexedSeq(G__6039__a,0,null); |
| } |
| return G__6038__delegate.call(this,args);}; |
| G__6038.cljs$lang$maxFixedArity = 0; |
| G__6038.cljs$lang$applyTo = (function (arglist__6040){ |
| var args = cljs.core.seq(arglist__6040); |
| return G__6038__delegate(args); |
| }); |
| G__6038.cljs$core$IFn$_invoke$arity$variadic = G__6038__delegate; |
| return G__6038; |
| })() |
| ; |
| }); |
| /** |
| * Replaces all instance of match with replacement in s. |
| * |
| * match/replacement can be: |
| * |
| * string / string |
| * pattern / (string or function of match). |
| * |
| * See also replace-first. |
| * |
| * The replacement is literal (i.e. none of its characters are treated |
| * specially) for all cases above except pattern / string. |
| * |
| * For pattern / string, $1, $2, etc. in the replacement string are |
| * substituted with the string that matched the corresponding |
| * parenthesized group in the pattern. |
| * |
| * Example: |
| * (clojure.string/replace "Almost Pig Latin" #"\b(\w)(\w+)\b" "$2$1ay") |
| * -> "lmostAay igPay atinLay" |
| */ |
| clojure.string.replace = (function clojure$string$replace(s,match,replacement){ |
| if(typeof match === 'string'){ |
| return s.replace((new RegExp(goog.string.regExpEscape(match),"g")),replacement); |
| } else { |
| if((match instanceof RegExp)){ |
| if(typeof replacement === 'string'){ |
| return clojure.string.replace_all.call(null,s,match,replacement); |
| } else { |
| return clojure.string.replace_all.call(null,s,match,clojure.string.replace_with.call(null,replacement)); |
| } |
| } else { |
| throw ["Invalid match arg: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(match)].join(''); |
| |
| } |
| } |
| }); |
| /** |
| * Replaces the first instance of match with replacement in s. |
| * |
| * match/replacement can be: |
| * |
| * string / string |
| * pattern / (string or function of match). |
| * |
| * See also replace. |
| * |
| * The replacement is literal (i.e. none of its characters are treated |
| * specially) for all cases above except pattern / string. |
| * |
| * For pattern / string, $1, $2, etc. in the replacement string are |
| * substituted with the string that matched the corresponding |
| * parenthesized group in the pattern. |
| * |
| * Example: |
| * (clojure.string/replace-first "swap first two words" |
| * #"(\w+)(\s+)(\w+)" "$3$2$1") |
| * -> "first swap two words" |
| */ |
| clojure.string.replace_first = (function clojure$string$replace_first(s,match,replacement){ |
| return s.replace(match,replacement); |
| }); |
| /** |
| * Returns a string of all elements in coll, as returned by (seq coll), |
| * separated by an optional separator. |
| */ |
| clojure.string.join = (function clojure$string$join(var_args){ |
| var G__6042 = arguments.length; |
| switch (G__6042) { |
| case 1: |
| return clojure.string.join.cljs$core$IFn$_invoke$arity$1((arguments[(0)])); |
| |
| break; |
| case 2: |
| return clojure.string.join.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); |
| |
| break; |
| default: |
| throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); |
| |
| } |
| }); |
| |
| (clojure.string.join.cljs$core$IFn$_invoke$arity$1 = (function (coll){ |
| var sb = (new goog.string.StringBuffer()); |
| var coll__$1 = cljs.core.seq.call(null,coll); |
| while(true){ |
| if((!((coll__$1 == null)))){ |
| var G__6044 = sb.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first.call(null,coll__$1))); |
| var G__6045 = cljs.core.next.call(null,coll__$1); |
| sb = G__6044; |
| coll__$1 = G__6045; |
| continue; |
| } else { |
| return sb.toString(); |
| } |
| break; |
| } |
| })); |
| |
| (clojure.string.join.cljs$core$IFn$_invoke$arity$2 = (function (separator,coll){ |
| var sb = (new goog.string.StringBuffer()); |
| var coll__$1 = cljs.core.seq.call(null,coll); |
| while(true){ |
| if((!((coll__$1 == null)))){ |
| sb.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first.call(null,coll__$1))); |
| |
| var coll__$2 = cljs.core.next.call(null,coll__$1); |
| if((coll__$2 == null)){ |
| } else { |
| sb.append(separator); |
| } |
| |
| var G__6046 = sb; |
| var G__6047 = coll__$2; |
| sb = G__6046; |
| coll__$1 = G__6047; |
| continue; |
| } else { |
| return sb.toString(); |
| } |
| break; |
| } |
| })); |
| |
| (clojure.string.join.cljs$lang$maxFixedArity = 2); |
| |
| /** |
| * Converts string to all upper-case. |
| */ |
| clojure.string.upper_case = (function clojure$string$upper_case(s){ |
| return s.toUpperCase(); |
| }); |
| /** |
| * Converts string to all lower-case. |
| */ |
| clojure.string.lower_case = (function clojure$string$lower_case(s){ |
| return s.toLowerCase(); |
| }); |
| /** |
| * Converts first character of the string to upper-case, all other |
| * characters to lower-case. |
| */ |
| clojure.string.capitalize = (function clojure$string$capitalize(s){ |
| return goog.string.capitalize(s); |
| }); |
| clojure.string.pop_last_while_empty = (function clojure$string$pop_last_while_empty(v){ |
| var v__$1 = v; |
| while(true){ |
| if(("" === cljs.core.peek.call(null,v__$1))){ |
| var G__6048 = cljs.core.pop.call(null,v__$1); |
| v__$1 = G__6048; |
| continue; |
| } else { |
| return v__$1; |
| } |
| break; |
| } |
| }); |
| clojure.string.discard_trailing_if_needed = (function clojure$string$discard_trailing_if_needed(limit,v){ |
| if(((((0) === limit)) && (((1) < cljs.core.count.call(null,v))))){ |
| return clojure.string.pop_last_while_empty.call(null,v); |
| } else { |
| return v; |
| } |
| }); |
| clojure.string.split_with_empty_regex = (function clojure$string$split_with_empty_regex(s,limit){ |
| if((((limit <= (0))) || ((limit >= ((2) + cljs.core.count.call(null,s)))))){ |
| return cljs.core.conj.call(null,cljs.core.vec.call(null,cljs.core.cons.call(null,"",cljs.core.map.call(null,cljs.core.str,cljs.core.seq.call(null,s)))),""); |
| } else { |
| var pred__6049 = cljs.core._EQ__EQ_; |
| var expr__6050 = limit; |
| if(cljs.core.truth_(pred__6049.call(null,(1),expr__6050))){ |
| return (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[s],null)); |
| } else { |
| if(cljs.core.truth_(pred__6049.call(null,(2),expr__6050))){ |
| return (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,["",s],null)); |
| } else { |
| var c = (limit - (2)); |
| return cljs.core.conj.call(null,cljs.core.vec.call(null,cljs.core.cons.call(null,"",cljs.core.subvec.call(null,cljs.core.vec.call(null,cljs.core.map.call(null,cljs.core.str,cljs.core.seq.call(null,s))),(0),c))),cljs.core.subs.call(null,s,c)); |
| } |
| } |
| } |
| }); |
| /** |
| * Splits string on a regular expression. Optional argument limit is |
| * the maximum number of splits. Not lazy. Returns vector of the splits. |
| */ |
| clojure.string.split = (function clojure$string$split(var_args){ |
| var G__6053 = arguments.length; |
| switch (G__6053) { |
| case 2: |
| return clojure.string.split.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); |
| |
| break; |
| case 3: |
| return clojure.string.split.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); |
| |
| break; |
| default: |
| throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); |
| |
| } |
| }); |
| |
| (clojure.string.split.cljs$core$IFn$_invoke$arity$2 = (function (s,re){ |
| return clojure.string.split.call(null,s,re,(0)); |
| })); |
| |
| (clojure.string.split.cljs$core$IFn$_invoke$arity$3 = (function (s,re,limit){ |
| return clojure.string.discard_trailing_if_needed.call(null,limit,((("/(?:)/" === cljs.core.str.cljs$core$IFn$_invoke$arity$1(re)))?clojure.string.split_with_empty_regex.call(null,s,limit):(((limit < (1)))?cljs.core.vec.call(null,cljs.core.str.cljs$core$IFn$_invoke$arity$1(s).split(re)):(function (){var s__$1 = s; |
| var limit__$1 = limit; |
| var parts = cljs.core.PersistentVector.EMPTY; |
| while(true){ |
| if(((1) === limit__$1)){ |
| return cljs.core.conj.call(null,parts,s__$1); |
| } else { |
| var m = cljs.core.re_find.call(null,re,s__$1); |
| if((!((m == null)))){ |
| var index = s__$1.indexOf(m); |
| var G__6055 = s__$1.substring((index + cljs.core.count.call(null,m))); |
| var G__6056 = (limit__$1 - (1)); |
| var G__6057 = cljs.core.conj.call(null,parts,s__$1.substring((0),index)); |
| s__$1 = G__6055; |
| limit__$1 = G__6056; |
| parts = G__6057; |
| continue; |
| } else { |
| return cljs.core.conj.call(null,parts,s__$1); |
| } |
| } |
| break; |
| } |
| })()))); |
| })); |
| |
| (clojure.string.split.cljs$lang$maxFixedArity = 3); |
| |
| /** |
| * Splits s on \n or \r\n. |
| */ |
| clojure.string.split_lines = (function clojure$string$split_lines(s){ |
| return clojure.string.split.call(null,s,/\n|\r\n/); |
| }); |
| /** |
| * Removes whitespace from both ends of string. |
| */ |
| clojure.string.trim = (function clojure$string$trim(s){ |
| return goog.string.trim(s); |
| }); |
| /** |
| * Removes whitespace from the left side of string. |
| */ |
| clojure.string.triml = (function clojure$string$triml(s){ |
| return goog.string.trimLeft(s); |
| }); |
| /** |
| * Removes whitespace from the right side of string. |
| */ |
| clojure.string.trimr = (function clojure$string$trimr(s){ |
| return goog.string.trimRight(s); |
| }); |
| /** |
| * Removes all trailing newline \n or return \r characters from |
| * string. Similar to Perl's chomp. |
| */ |
| clojure.string.trim_newline = (function clojure$string$trim_newline(s){ |
| var index = s.length; |
| while(true){ |
| if((index === (0))){ |
| return ""; |
| } else { |
| var ch = cljs.core.get.call(null,s,(index - (1))); |
| if(((("\n" === ch)) || (("\r" === ch)))){ |
| var G__6058 = (index - (1)); |
| index = G__6058; |
| continue; |
| } else { |
| return s.substring((0),index); |
| } |
| } |
| break; |
| } |
| }); |
| /** |
| * True is s is nil, empty, or contains only whitespace. |
| */ |
| clojure.string.blank_QMARK_ = (function clojure$string$blank_QMARK_(s){ |
| return goog.string.isEmptyOrWhitespace(goog.string.makeSafe(s)); |
| }); |
| /** |
| * Return a new string, using cmap to escape each character ch |
| * from s as follows: |
| * |
| * If (cmap ch) is nil, append ch to the new string. |
| * If (cmap ch) is non-nil, append (str (cmap ch)) instead. |
| */ |
| clojure.string.escape = (function clojure$string$escape(s,cmap){ |
| var buffer = (new goog.string.StringBuffer()); |
| var length = s.length; |
| var index = (0); |
| while(true){ |
| if((length === index)){ |
| return buffer.toString(); |
| } else { |
| var ch = s.charAt(index); |
| var replacement = cljs.core.get.call(null,cmap,ch); |
| if((!((replacement == null)))){ |
| buffer.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(replacement)); |
| } else { |
| buffer.append(ch); |
| } |
| |
| var G__6059 = (index + (1)); |
| index = G__6059; |
| continue; |
| } |
| break; |
| } |
| }); |
| /** |
| * Return index of value (string or char) in s, optionally searching |
| * forward from from-index or nil if not found. |
| */ |
| clojure.string.index_of = (function clojure$string$index_of(var_args){ |
| var G__6061 = arguments.length; |
| switch (G__6061) { |
| case 2: |
| return clojure.string.index_of.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); |
| |
| break; |
| case 3: |
| return clojure.string.index_of.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); |
| |
| break; |
| default: |
| throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); |
| |
| } |
| }); |
| |
| (clojure.string.index_of.cljs$core$IFn$_invoke$arity$2 = (function (s,value){ |
| var result = s.indexOf(value); |
| if((result < (0))){ |
| return null; |
| } else { |
| return result; |
| } |
| })); |
| |
| (clojure.string.index_of.cljs$core$IFn$_invoke$arity$3 = (function (s,value,from_index){ |
| var result = s.indexOf(value,from_index); |
| if((result < (0))){ |
| return null; |
| } else { |
| return result; |
| } |
| })); |
| |
| (clojure.string.index_of.cljs$lang$maxFixedArity = 3); |
| |
| /** |
| * Return last index of value (string or char) in s, optionally |
| * searching backward from from-index or nil if not found. |
| */ |
| clojure.string.last_index_of = (function clojure$string$last_index_of(var_args){ |
| var G__6064 = arguments.length; |
| switch (G__6064) { |
| case 2: |
| return clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)])); |
| |
| break; |
| case 3: |
| return clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)])); |
| |
| break; |
| default: |
| throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join(''))); |
| |
| } |
| }); |
| |
| (clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$2 = (function (s,value){ |
| var result = s.lastIndexOf(value); |
| if((result < (0))){ |
| return null; |
| } else { |
| return result; |
| } |
| })); |
| |
| (clojure.string.last_index_of.cljs$core$IFn$_invoke$arity$3 = (function (s,value,from_index){ |
| var result = s.lastIndexOf(value,from_index); |
| if((result < (0))){ |
| return null; |
| } else { |
| return result; |
| } |
| })); |
| |
| (clojure.string.last_index_of.cljs$lang$maxFixedArity = 3); |
| |
| /** |
| * True if s starts with substr. |
| */ |
| clojure.string.starts_with_QMARK_ = (function clojure$string$starts_with_QMARK_(s,substr){ |
| return goog.string.startsWith(s,substr); |
| }); |
| /** |
| * True if s ends with substr. |
| */ |
| clojure.string.ends_with_QMARK_ = (function clojure$string$ends_with_QMARK_(s,substr){ |
| return goog.string.endsWith(s,substr); |
| }); |
| /** |
| * True if s includes substr. |
| */ |
| clojure.string.includes_QMARK_ = (function clojure$string$includes_QMARK_(s,substr){ |
| return goog.string.contains(s,substr); |
| }); |
| |
| //# sourceMappingURL=string.js.map |