505 lines
14 KiB
JavaScript
505 lines
14 KiB
JavaScript
// Compiled by ClojureScript 1.9.473 {}
|
|
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){
|
|
return s.replace((new RegExp(re.source,"g")),replacement);
|
|
});
|
|
clojure.string.replace_with = (function clojure$string$replace_with(f){
|
|
return (function() {
|
|
var G__8073__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__8073 = function (var_args){
|
|
var args = null;
|
|
if (arguments.length > 0) {
|
|
var G__8074__i = 0, G__8074__a = new Array(arguments.length - 0);
|
|
while (G__8074__i < G__8074__a.length) {G__8074__a[G__8074__i] = arguments[G__8074__i + 0]; ++G__8074__i;}
|
|
args = new cljs.core.IndexedSeq(G__8074__a,0);
|
|
}
|
|
return G__8073__delegate.call(this,args);};
|
|
G__8073.cljs$lang$maxFixedArity = 0;
|
|
G__8073.cljs$lang$applyTo = (function (arglist__8075){
|
|
var args = cljs.core.seq(arglist__8075);
|
|
return G__8073__delegate(args);
|
|
});
|
|
G__8073.cljs$core$IFn$_invoke$arity$variadic = G__8073__delegate;
|
|
return G__8073;
|
|
})()
|
|
;
|
|
});
|
|
/**
|
|
* Replaces all instance of match with replacement in s.
|
|
* match/replacement can be:
|
|
*
|
|
* string / string
|
|
* pattern / (string or function of match).
|
|
*/
|
|
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 [cljs.core.str.cljs$core$IFn$_invoke$arity$1("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).
|
|
*/
|
|
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 args8076 = [];
|
|
var len__7927__auto___8079 = arguments.length;
|
|
var i__7928__auto___8080 = (0);
|
|
while(true){
|
|
if((i__7928__auto___8080 < len__7927__auto___8079)){
|
|
args8076.push((arguments[i__7928__auto___8080]));
|
|
|
|
var G__8081 = (i__7928__auto___8080 + (1));
|
|
i__7928__auto___8080 = G__8081;
|
|
continue;
|
|
} else {
|
|
}
|
|
break;
|
|
}
|
|
|
|
var G__8078 = args8076.length;
|
|
switch (G__8078) {
|
|
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([cljs.core.str.cljs$core$IFn$_invoke$arity$1("Invalid arity: "),cljs.core.str.cljs$core$IFn$_invoke$arity$1(args8076.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__8083 = sb.append([cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first.call(null,coll__$1))].join(''));
|
|
var G__8084 = cljs.core.next.call(null,coll__$1);
|
|
sb = G__8083;
|
|
coll__$1 = G__8084;
|
|
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))].join(''));
|
|
|
|
var coll__$2 = cljs.core.next.call(null,coll__$1);
|
|
if((coll__$2 == null)){
|
|
} else {
|
|
sb.append(separator);
|
|
}
|
|
|
|
var G__8085 = sb;
|
|
var G__8086 = coll__$2;
|
|
sb = G__8085;
|
|
coll__$1 = G__8086;
|
|
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){
|
|
if((cljs.core.count.call(null,s) < (2))){
|
|
return clojure.string.upper_case.call(null,s);
|
|
} else {
|
|
return [cljs.core.str.cljs$core$IFn$_invoke$arity$1(clojure.string.upper_case.call(null,cljs.core.subs.call(null,s,(0),(1)))),cljs.core.str.cljs$core$IFn$_invoke$arity$1(clojure.string.lower_case.call(null,cljs.core.subs.call(null,s,(1))))].join('');
|
|
}
|
|
});
|
|
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__8087 = cljs.core.pop.call(null,v__$1);
|
|
v__$1 = G__8087;
|
|
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__8091 = cljs.core._EQ__EQ_;
|
|
var expr__8092 = limit;
|
|
if(cljs.core.truth_(pred__8091.call(null,(1),expr__8092))){
|
|
return (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[s],null));
|
|
} else {
|
|
if(cljs.core.truth_(pred__8091.call(null,(2),expr__8092))){
|
|
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 args8094 = [];
|
|
var len__7927__auto___8097 = arguments.length;
|
|
var i__7928__auto___8098 = (0);
|
|
while(true){
|
|
if((i__7928__auto___8098 < len__7927__auto___8097)){
|
|
args8094.push((arguments[i__7928__auto___8098]));
|
|
|
|
var G__8099 = (i__7928__auto___8098 + (1));
|
|
i__7928__auto___8098 = G__8099;
|
|
continue;
|
|
} else {
|
|
}
|
|
break;
|
|
}
|
|
|
|
var G__8096 = args8094.length;
|
|
switch (G__8096) {
|
|
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([cljs.core.str.cljs$core$IFn$_invoke$arity$1("Invalid arity: "),cljs.core.str.cljs$core$IFn$_invoke$arity$1(args8094.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)].join('')))?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)].join('').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__8101 = s__$1.substring((index + cljs.core.count.call(null,m)));
|
|
var G__8102 = (limit__$1 - (1));
|
|
var G__8103 = cljs.core.conj.call(null,parts,s__$1.substring((0),index));
|
|
s__$1 = G__8101;
|
|
limit__$1 = G__8102;
|
|
parts = G__8103;
|
|
continue;
|
|
} else {
|
|
return cljs.core.conj.call(null,parts,s__$1);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
})())));
|
|
});
|
|
|
|
clojure.string.split.cljs$lang$maxFixedArity = 3;
|
|
|
|
/**
|
|
* Splits s on
|
|
* or
|
|
* .
|
|
*/
|
|
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__8104 = (index - (1));
|
|
index = G__8104;
|
|
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.isEmptySafe(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)].join(''));
|
|
} else {
|
|
buffer.append(ch);
|
|
}
|
|
|
|
var G__8105 = (index + (1));
|
|
index = G__8105;
|
|
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 args8106 = [];
|
|
var len__7927__auto___8109 = arguments.length;
|
|
var i__7928__auto___8110 = (0);
|
|
while(true){
|
|
if((i__7928__auto___8110 < len__7927__auto___8109)){
|
|
args8106.push((arguments[i__7928__auto___8110]));
|
|
|
|
var G__8111 = (i__7928__auto___8110 + (1));
|
|
i__7928__auto___8110 = G__8111;
|
|
continue;
|
|
} else {
|
|
}
|
|
break;
|
|
}
|
|
|
|
var G__8108 = args8106.length;
|
|
switch (G__8108) {
|
|
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([cljs.core.str.cljs$core$IFn$_invoke$arity$1("Invalid arity: "),cljs.core.str.cljs$core$IFn$_invoke$arity$1(args8106.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 args8113 = [];
|
|
var len__7927__auto___8116 = arguments.length;
|
|
var i__7928__auto___8117 = (0);
|
|
while(true){
|
|
if((i__7928__auto___8117 < len__7927__auto___8116)){
|
|
args8113.push((arguments[i__7928__auto___8117]));
|
|
|
|
var G__8118 = (i__7928__auto___8117 + (1));
|
|
i__7928__auto___8117 = G__8118;
|
|
continue;
|
|
} else {
|
|
}
|
|
break;
|
|
}
|
|
|
|
var G__8115 = args8113.length;
|
|
switch (G__8115) {
|
|
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([cljs.core.str.cljs$core$IFn$_invoke$arity$1("Invalid arity: "),cljs.core.str.cljs$core$IFn$_invoke$arity$1(args8113.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
|