@p4ulcristian/iris-layout 0.2.0 → 0.2.2

package/dist/cljs-runtime/clojure.string.js

@@ -0,0 +1,480 @@
+import "./cljs_env.js";
+import "./cljs.core.js";
+import "./goog.string.string.js";
+import "./goog.string.stringbuffer.js";
+goog.provide('clojure.string');
+clojure.string.seq_reverse = (function clojure$string$seq_reverse(coll){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3(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__8014 = "g";
+var G__8014__$1 = (cljs.core.truth_(re.ignoreCase)?[G__8014,"i"].join(''):G__8014);
+var G__8014__$2 = (cljs.core.truth_(re.multiline)?[G__8014__$1,"m"].join(''):G__8014__$1);
+if(cljs.core.truth_(re.unicode)){
+return [G__8014__$2,"u"].join('');
+} else {
+return G__8014__$2;
+}
+})()));
+return s.replace(r,replacement);
+});
+clojure.string.replace_with = (function clojure$string$replace_with(f){
+return (function() { 
+var G__8186__delegate = function (args){
+var matches = cljs.core.drop_last.cljs$core$IFn$_invoke$arity$2((2),args);
+if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(cljs.core.count(matches),(1))){
+var G__8020 = cljs.core.first(matches);
+return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__8020) : f.call(null,G__8020));
+} else {
+var G__8022 = cljs.core.vec(matches);
+return (f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(G__8022) : f.call(null,G__8022));
+}
+};
+var G__8186 = function (var_args){
+var args = null;
+if (arguments.length > 0) {
+var G__8193__i = 0, G__8193__a = new Array(arguments.length -  0);
+while (G__8193__i < G__8193__a.length) {G__8193__a[G__8193__i] = arguments[G__8193__i + 0]; ++G__8193__i;}
+  args = new cljs.core.IndexedSeq(G__8193__a,0,null);
+} 
+return G__8186__delegate.call(this,args);};
+G__8186.cljs$lang$maxFixedArity = 0;
+G__8186.cljs$lang$applyTo = (function (arglist__8197){
+var args = cljs.core.seq(arglist__8197);
+return G__8186__delegate(args);
+});
+G__8186.cljs$core$IFn$_invoke$arity$variadic = G__8186__delegate;
+return G__8186;
+})()
+;
+});
+/**
+ * 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(s,match,replacement);
+} else {
+return clojure.string.replace_all(s,match,clojure.string.replace_with(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__8031 = arguments.length;
+switch (G__8031) {
+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(coll);
+while(true){
+if((!((coll__$1 == null)))){
+var G__8218 = sb.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(coll__$1)));
+var G__8219 = cljs.core.next(coll__$1);
+sb = G__8218;
+coll__$1 = G__8219;
+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(coll);
+while(true){
+if((!((coll__$1 == null)))){
+sb.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(cljs.core.first(coll__$1)));
+
+var coll__$2 = cljs.core.next(coll__$1);
+if((coll__$2 == null)){
+} else {
+sb.append(separator);
+}
+
+var G__8229 = sb;
+var G__8230 = coll__$2;
+sb = G__8229;
+coll__$1 = G__8230;
+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(v__$1))){
+var G__8238 = cljs.core.pop(v__$1);
+v__$1 = G__8238;
+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(v))))){
+return clojure.string.pop_last_while_empty(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(s)))))){
+return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.vec(cljs.core.cons("",cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.seq(s)))),"");
+} else {
+var pred__8053 = cljs.core._EQ__EQ_;
+var expr__8054 = limit;
+if(cljs.core.truth_((pred__8053.cljs$core$IFn$_invoke$arity$2 ? pred__8053.cljs$core$IFn$_invoke$arity$2((1),expr__8054) : pred__8053.call(null,(1),expr__8054)))){
+return (new cljs.core.PersistentVector(null,1,(5),cljs.core.PersistentVector.EMPTY_NODE,[s],null));
+} else {
+if(cljs.core.truth_((pred__8053.cljs$core$IFn$_invoke$arity$2 ? pred__8053.cljs$core$IFn$_invoke$arity$2((2),expr__8054) : pred__8053.call(null,(2),expr__8054)))){
+return (new cljs.core.PersistentVector(null,2,(5),cljs.core.PersistentVector.EMPTY_NODE,["",s],null));
+} else {
+var c = (limit - (2));
+return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(cljs.core.vec(cljs.core.cons("",cljs.core.subvec.cljs$core$IFn$_invoke$arity$3(cljs.core.vec(cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.str,cljs.core.seq(s))),(0),c))),cljs.core.subs.cljs$core$IFn$_invoke$arity$2(s,c));
+}
+}
+}
+});
+/**
+ * Splits string on a regular expression. Optional argument limit is
+ *   the maximum number of parts. Not lazy. Returns vector of the parts.
+ *   Trailing empty strings are not returned - pass limit of -1 to return all.
+ */
+clojure.string.split = (function clojure$string$split(var_args){
+var G__8073 = arguments.length;
+switch (G__8073) {
+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.cljs$core$IFn$_invoke$arity$3(s,re,(0));
+}));
+
+(clojure.string.split.cljs$core$IFn$_invoke$arity$3 = (function (s,re,limit){
+return clojure.string.discard_trailing_if_needed(limit,((("/(?:)/" === cljs.core.str.cljs$core$IFn$_invoke$arity$1(re)))?clojure.string.split_with_empty_regex(s,limit):(((limit < (1)))?cljs.core.vec(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.cljs$core$IFn$_invoke$arity$2(parts,s__$1);
+} else {
+var m = cljs.core.re_find(re,s__$1);
+if((!((m == null)))){
+var index = s__$1.indexOf(m);
+var G__8271 = s__$1.substring((index + cljs.core.count(m)));
+var G__8272 = (limit__$1 - (1));
+var G__8273 = cljs.core.conj.cljs$core$IFn$_invoke$arity$2(parts,s__$1.substring((0),index));
+s__$1 = G__8271;
+limit__$1 = G__8272;
+parts = G__8273;
+continue;
+} else {
+return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(parts,s__$1);
+}
+}
+break;
+}
+})())));
+}));
+
+(clojure.string.split.cljs$lang$maxFixedArity = 3);
+
+/**
+ * Splits s on \n or \r\n. Trailing empty lines are not returned.
+ */
+clojure.string.split_lines = (function clojure$string$split_lines(s){
+return clojure.string.split.cljs$core$IFn$_invoke$arity$2(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.cljs$core$IFn$_invoke$arity$2(s,(index - (1)));
+if(((("\n" === ch)) || (("\r" === ch)))){
+var G__8292 = (index - (1));
+index = G__8292;
+continue;
+} else {
+return s.substring((0),index);
+}
+}
+break;
+}
+});
+/**
+ * True if 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 = (cmap.cljs$core$IFn$_invoke$arity$1 ? cmap.cljs$core$IFn$_invoke$arity$1(ch) : cmap.call(null,ch));
+if((!((replacement == null)))){
+buffer.append(cljs.core.str.cljs$core$IFn$_invoke$arity$1(replacement));
+} else {
+buffer.append(ch);
+}
+
+var G__8307 = (index + (1));
+index = G__8307;
+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__8132 = arguments.length;
+switch (G__8132) {
+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__8161 = arguments.length;
+switch (G__8161) {
+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=clojure.string.js.map

package/dist/cljs-runtime/clojure.string.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["clojure/string.cljs"],"mappings":"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","names":["clojure.string/seq-reverse","coll","cljs.core.reduce","cljs.core/conj","clojure.string/re-surrogate-pair","js/RegExp","clojure.string/reverse","s","clojure.string/replace-all","re","replacement","r","G__8014","clojure.string/replace-with","f","args","matches","cljs.core.drop_last","cljs.core._EQ_","cljs.core/count","G__8020","cljs.core/first","G__8022","cljs.core/vec","clojure.string/replace","match","goog.string/regExpEscape","clojure.string/replace-first","var_args","G__8031","clojure.string/join","js/Error","sb","js/goog.string.StringBuffer","cljs.core/seq","cljs.core/next","separator","clojure.string/upper-case","clojure.string/lower-case","clojure.string/capitalize","goog.string/capitalize","clojure.string/pop-last-while-empty","v","cljs.core/peek","cljs.core/pop","clojure.string/discard-trailing-if-needed","limit","clojure.string/split-with-empty-regex","cljs.core.conj","cljs.core/cons","cljs.core.map","cljs.core/str","pred__8053","expr__8054","cljs.core/==","cljs.core/PersistentVector","c","cljs.core.subvec","cljs.core.subs","G__8073","clojure.string/split","clojure.string.split","parts","m","cljs.core/re-find","index","clojure.string/split-lines","clojure.string/trim","goog.string/trim","clojure.string/triml","goog.string/trimLeft","clojure.string/trimr","goog.string/trimRight","clojure.string/trim-newline","ch","cljs.core.get","clojure.string/blank?","goog.string/isEmptyOrWhitespace","goog.string/makeSafe","clojure.string/escape","cmap","buffer","length","G__8132","clojure.string/index-of","value","result","from-index","G__8161","clojure.string/last-index-of","clojure.string/starts-with?","substr","goog.string/startsWith","clojure.string/ends-with?","goog.string/endsWith","clojure.string/includes?","goog.string/contains"],"sourcesContent":[";   Copyright (c) Rich Hickey. All rights reserved.\n;   The use and distribution terms for this software are covered by the\n;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)\n;   which can be found in the file epl-v10.html at the root of this distribution.\n;   By using this software in any fashion, you are agreeing to be bound by\n;   the terms of this license.\n;   You must not remove this notice, or any other, from this software.\n\n(ns clojure.string\n  (:refer-clojure :exclude [replace reverse])\n  (:require [goog.string :as gstring])\n  (:import [goog.string StringBuffer]))\n\n(defn- seq-reverse\n  [coll]\n  (reduce conj () coll))\n\n(def ^:private re-surrogate-pair\n  (js/RegExp. \"([\\\\uD800-\\\\uDBFF])([\\\\uDC00-\\\\uDFFF])\" \"g\"))\n\n(defn ^string reverse\n  \"Returns s with its characters reversed.\"\n  [s]\n  (-> (.replace s re-surrogate-pair \"$2$1\")\n      (.. (split \"\") (reverse) (join \"\"))))\n\n(defn- replace-all\n  [s re replacement]\n  (let [r (js/RegExp. (.-source re)\n                      (cond-> \"g\"\n                        (.-ignoreCase re) (str \"i\")\n                        (.-multiline re) (str \"m\")\n                        (.-unicode re) (str \"u\")))]\n    (.replace s r replacement)))\n\n(defn- replace-with\n  [f]\n  (fn [& args]\n    (let [matches (drop-last 2 args)]\n      (if (= (count matches) 1)\n        (f (first matches))\n        (f (vec matches))))))\n\n(defn ^string replace\n  \"Replaces all instance of match with replacement in s.\n\n   match/replacement can be:\n\n   string / string\n   pattern / (string or function of match).\n\n   See also replace-first.\n\n   The replacement is literal (i.e. none of its characters are treated\n   specially) for all cases above except pattern / string.\n\n   For pattern / string, $1, $2, etc. in the replacement string are\n   substituted with the string that matched the corresponding\n   parenthesized group in the pattern.\n\n   Example:\n   (clojure.string/replace \\\"Almost Pig Latin\\\" #\\\"\\\\b(\\\\w)(\\\\w+)\\\\b\\\" \\\"$2$1ay\\\")\n   -> \\\"lmostAay igPay atinLay\\\"\"\n  [s match replacement]\n  (cond\n    (string? match)\n    (.replace s (js/RegExp. (gstring/regExpEscape match) \"g\") replacement)\n\n    (instance? js/RegExp match)\n    (if (string? replacement)\n      (replace-all s match replacement)\n      (replace-all s match (replace-with replacement)))\n\n    :else (throw (str \"Invalid match arg: \" match))))\n\n(defn ^string replace-first\n  \"Replaces the first instance of match with replacement in s.\n\n   match/replacement can be:\n\n   string / string\n   pattern / (string or function of match).\n\n   See also replace.\n\n   The replacement is literal (i.e. none of its characters are treated\n   specially) for all cases above except pattern / string.\n\n   For pattern / string, $1, $2, etc. in the replacement string are\n   substituted with the string that matched the corresponding\n   parenthesized group in the pattern.\n\n   Example:\n   (clojure.string/replace-first \\\"swap first two words\\\"\n                                 #\\\"(\\\\w+)(\\\\s+)(\\\\w+)\\\" \\\"$3$2$1\\\")\n   -> \\\"first swap two words\\\"\"\n  [s match replacement]\n  (.replace s match replacement))\n\n(defn join\n  \"Returns a string of all elements in coll, as returned by (seq coll),\n  separated by an optional separator.\"\n  ([coll]\n   (loop [sb (StringBuffer.) coll (seq coll)]\n     (if-not (nil? coll)\n       (recur (. sb (append (str (first coll)))) (next coll))\n       ^string (.toString sb))))\n  ([separator coll]\n   (loop [sb (StringBuffer.) coll (seq coll)]\n     (if-not (nil? coll)\n       (do\n         (. sb (append (str (first coll))))\n         (let [coll (next coll)]\n           (when-not (nil? coll)\n             (. sb (append separator)))\n           (recur sb coll)))\n       ^string (.toString sb)))))\n\n(defn ^string upper-case\n  \"Converts string to all upper-case.\"\n  [s]\n  (.toUpperCase s))\n\n(defn ^string lower-case\n  \"Converts string to all lower-case.\"\n  [s]\n  (.toLowerCase s))\n\n(defn ^string capitalize\n  \"Converts first character of the string to upper-case, all other\n  characters to lower-case.\"\n  [s]\n  (gstring/capitalize s))\n\n;; The JavaScript split function takes a limit argument but the return\n;; value is not the same as the Java split function.\n;;\n;; Java: (.split \"a-b-c\" #\"-\" 2) => [\"a\" \"b-c\"]\n;; JavaScript: (.split \"a-b-c\" #\"-\" 2) => [\"a\" \"b\"]\n;;\n;; For consistency, the three arg version has been implemented to\n;; mimic Java's behavior.\n\n(defn- pop-last-while-empty\n  [v]\n  (loop [v v]\n    (if (identical? \"\" (peek v))\n      (recur (pop v))\n      v)))\n\n(defn- discard-trailing-if-needed\n  [limit v]\n  (if (and (== 0 limit) (< 1 (count v)))\n    (pop-last-while-empty v)\n    v))\n\n(defn- split-with-empty-regex\n  [s limit]\n  (if (or (<= limit 0) (>= limit (+ 2 (count s))))\n    (conj (vec (cons \"\" (map str (seq s)))) \"\")\n    (condp == limit\n      1 (vector s)\n      2 (vector \"\" s)\n      (let [c (- limit 2)]\n        (conj (vec (cons \"\" (subvec (vec (map str (seq s))) 0 c))) (subs s c))))))\n\n(defn split\n  \"Splits string on a regular expression. Optional argument limit is\n  the maximum number of parts. Not lazy. Returns vector of the parts.\n  Trailing empty strings are not returned - pass limit of -1 to return all.\"\n  ([s re]\n     (split s re 0))\n    ([s re limit]\n     (discard-trailing-if-needed limit\n       (if (identical? \"/(?:)/\" (str re))\n         (split-with-empty-regex s limit)\n         (if (< limit 1)\n           (vec (.split (str s) re))\n           (loop [s s\n                  limit limit\n                  parts []]\n             (if (== 1 limit)\n               (conj parts s)\n               (let [m (re-find re s)]\n                 (if-not (nil? m)\n                   (let [index (.indexOf s m)]\n                     (recur (.substring s (+ index (count m)))\n                       (dec limit)\n                       (conj parts (.substring s 0 index))))\n                   (conj parts s))))))))))\n\n(defn split-lines\n  \"Splits s on \\\\n or \\\\r\\\\n. Trailing empty lines are not returned.\"\n  [s]\n  (split s #\"\\n|\\r\\n\"))\n\n(defn ^string trim\n  \"Removes whitespace from both ends of string.\"\n  [s]\n  (gstring/trim s))\n\n(defn ^string triml\n  \"Removes whitespace from the left side of string.\"\n  [s]\n  (gstring/trimLeft s))\n\n(defn ^string trimr\n  \"Removes whitespace from the right side of string.\"\n  [s]\n  (gstring/trimRight s))\n\n(defn ^string trim-newline\n  \"Removes all trailing newline \\\\n or return \\\\r characters from\n  string.  Similar to Perl's chomp.\"\n  [s]\n  (loop [index (.-length s)]\n    (if (zero? index)\n      \"\"\n      (let [ch (get s (dec index))]\n        (if (or (identical? \\newline ch)\n                (identical? \\return ch))\n          (recur (dec index))\n          (.substring s 0 index))))))\n\n(defn ^boolean blank?\n  \"True if s is nil, empty, or contains only whitespace.\"\n  [s]\n  (gstring/isEmptyOrWhitespace (gstring/makeSafe s)))\n\n(defn ^string escape\n  \"Return a new string, using cmap to escape each character ch\n   from s as follows:\n\n   If (cmap ch) is nil, append ch to the new string.\n   If (cmap ch) is non-nil, append (str (cmap ch)) instead.\"\n  [s cmap]\n  (let [buffer (StringBuffer.)\n        length (.-length s)]\n    (loop [index 0]\n      (if (== length index)\n        (. buffer (toString))\n        (let [ch (.charAt s index)\n              replacement (cmap ch)]\n          (if-not (nil? replacement)\n            (.append buffer (str replacement))\n            (.append buffer ch))\n          (recur (inc index)))))))\n\n(defn index-of\n  \"Return index of value (string or char) in s, optionally searching\n  forward from from-index or nil if not found.\"\n  ([s value]\n   (let [result (.indexOf s value)]\n     (if (neg? result)\n       nil\n       result)))\n  ([s value from-index]\n   (let [result (.indexOf s value from-index)]\n     (if (neg? result)\n       nil\n       result))))\n\n(defn last-index-of\n  \"Return last index of value (string or char) in s, optionally\n  searching backward from from-index or nil if not found.\"\n  ([s value]\n   (let [result (.lastIndexOf s value)]\n     (if (neg? result)\n       nil\n       result)))\n  ([s value from-index]\n   (let [result (.lastIndexOf s value from-index)]\n     (if (neg? result)\n       nil\n       result))))\n\n(defn ^boolean starts-with?\n  \"True if s starts with substr.\"\n  [s substr]\n  (gstring/startsWith s substr))\n\n(defn ^boolean ends-with?\n  \"True if s ends with substr.\"\n  [s substr]\n  (gstring/endsWith s substr))\n\n(defn ^boolean includes?\n  \"True if s includes substr.\"\n  [s substr]\n  (gstring/contains s substr))\n"],"x_google_ignoreList":[0]}

package/dist/cljs-runtime/clojure.walk.js

@@ -0,0 +1,132 @@
+import "./cljs_env.js";
+import "./cljs.core.js";
+goog.provide('clojure.walk');
+/**
+ * Traverses form, an arbitrary data structure.  inner and outer are
+ *   functions.  Applies inner to each element of form, building up a
+ *   data structure of the same type, then applies outer to the result.
+ *   Recognizes all Clojure data structures. Consumes seqs as with doall.
+ */
+clojure.walk.walk = (function clojure$walk$walk(inner,outer,form){
+if(cljs.core.list_QMARK_(form)){
+var G__8648 = cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.list,cljs.core.map.cljs$core$IFn$_invoke$arity$2(inner,form));
+return (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(G__8648) : outer.call(null,G__8648));
+} else {
+if(cljs.core.map_entry_QMARK_(form)){
+var G__8651 = (new cljs.core.MapEntry((function (){var G__8653 = cljs.core.key(form);
+return (inner.cljs$core$IFn$_invoke$arity$1 ? inner.cljs$core$IFn$_invoke$arity$1(G__8653) : inner.call(null,G__8653));
+})(),(function (){var G__8655 = cljs.core.val(form);
+return (inner.cljs$core$IFn$_invoke$arity$1 ? inner.cljs$core$IFn$_invoke$arity$1(G__8655) : inner.call(null,G__8655));
+})(),null));
+return (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(G__8651) : outer.call(null,G__8651));
+} else {
+if(cljs.core.seq_QMARK_(form)){
+var G__8658 = cljs.core.doall.cljs$core$IFn$_invoke$arity$1(cljs.core.map.cljs$core$IFn$_invoke$arity$2(inner,form));
+return (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(G__8658) : outer.call(null,G__8658));
+} else {
+if(cljs.core.record_QMARK_(form)){
+var G__8662 = cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (r,x){
+return cljs.core.conj.cljs$core$IFn$_invoke$arity$2(r,(inner.cljs$core$IFn$_invoke$arity$1 ? inner.cljs$core$IFn$_invoke$arity$1(x) : inner.call(null,x)));
+}),form,form);
+return (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(G__8662) : outer.call(null,G__8662));
+} else {
+if(cljs.core.coll_QMARK_(form)){
+var G__8665 = cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.empty(form),cljs.core.map.cljs$core$IFn$_invoke$arity$2(inner,form));
+return (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(G__8665) : outer.call(null,G__8665));
+} else {
+return (outer.cljs$core$IFn$_invoke$arity$1 ? outer.cljs$core$IFn$_invoke$arity$1(form) : outer.call(null,form));
+
+}
+}
+}
+}
+}
+});
+/**
+ * Performs a depth-first, post-order traversal of form.  Calls f on
+ *   each sub-form, uses f's return value in place of the original.
+ *   Recognizes all Clojure data structures. Consumes seqs as with doall.
+ */
+clojure.walk.postwalk = (function clojure$walk$postwalk(f,form){
+return clojure.walk.walk(cljs.core.partial.cljs$core$IFn$_invoke$arity$2(clojure.walk.postwalk,f),f,form);
+});
+/**
+ * Like postwalk, but does pre-order traversal.
+ */
+clojure.walk.prewalk = (function clojure$walk$prewalk(f,form){
+return clojure.walk.walk(cljs.core.partial.cljs$core$IFn$_invoke$arity$2(clojure.walk.prewalk,f),cljs.core.identity,(f.cljs$core$IFn$_invoke$arity$1 ? f.cljs$core$IFn$_invoke$arity$1(form) : f.call(null,form)));
+});
+/**
+ * Recursively transforms all map keys from strings to keywords.
+ */
+clojure.walk.keywordize_keys = (function clojure$walk$keywordize_keys(m){
+var f = (function (p__8680){
+var vec__8681 = p__8680;
+var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__8681,(0),null);
+var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__8681,(1),null);
+if(typeof k === 'string'){
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.keyword.cljs$core$IFn$_invoke$arity$1(k),v], null);
+} else {
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,v], null);
+}
+});
+return clojure.walk.postwalk((function (x){
+if(cljs.core.map_QMARK_(x)){
+return cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$2(f,x));
+} else {
+return x;
+}
+}),m);
+});
+/**
+ * Recursively transforms all map keys from keywords to strings.
+ */
+clojure.walk.stringify_keys = (function clojure$walk$stringify_keys(m){
+var f = (function (p__8696){
+var vec__8700 = p__8696;
+var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__8700,(0),null);
+var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__8700,(1),null);
+if((k instanceof cljs.core.Keyword)){
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.name(k),v], null);
+} else {
+return new cljs.core.PersistentVector(null, 2, 5, cljs.core.PersistentVector.EMPTY_NODE, [k,v], null);
+}
+});
+return clojure.walk.postwalk((function (x){
+if(cljs.core.map_QMARK_(x)){
+return cljs.core.into.cljs$core$IFn$_invoke$arity$2(cljs.core.PersistentArrayMap.EMPTY,cljs.core.map.cljs$core$IFn$_invoke$arity$2(f,x));
+} else {
+return x;
+}
+}),m);
+});
+/**
+ * Recursively transforms form by replacing keys in smap with their
+ *   values.  Like clojure/replace but works on any data structure.  Does
+ *   replacement at the root of the tree first.
+ */
+clojure.walk.prewalk_replace = (function clojure$walk$prewalk_replace(smap,form){
+return clojure.walk.prewalk((function (x){
+if(cljs.core.contains_QMARK_(smap,x)){
+return (smap.cljs$core$IFn$_invoke$arity$1 ? smap.cljs$core$IFn$_invoke$arity$1(x) : smap.call(null,x));
+} else {
+return x;
+}
+}),form);
+});
+/**
+ * Recursively transforms form by replacing keys in smap with their
+ *   values.  Like clojure/replace but works on any data structure.  Does
+ *   replacement at the leaves of the tree first.
+ */
+clojure.walk.postwalk_replace = (function clojure$walk$postwalk_replace(smap,form){
+return clojure.walk.postwalk((function (x){
+if(cljs.core.contains_QMARK_(smap,x)){
+return (smap.cljs$core$IFn$_invoke$arity$1 ? smap.cljs$core$IFn$_invoke$arity$1(x) : smap.call(null,x));
+} else {
+return x;
+}
+}),form);
+});
+
+//# sourceMappingURL=clojure.walk.js.map

package/dist/cljs-runtime/clojure.walk.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["clojure/walk.cljs"],"mappings":"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","names":["clojure.walk/walk","inner","outer","form","cljs.core/list?","G__8648","cljs.core.apply","cljs.core/list","cljs.core.map","cljs.core/map-entry?","G__8651","cljs.core/MapEntry","G__8653","cljs.core/key","G__8655","cljs.core/val","cljs.core/seq?","G__8658","cljs.core.doall","cljs.core/record?","G__8662","cljs.core.reduce","r","x","cljs.core.conj","cljs.core/coll?","G__8665","cljs.core.into","cljs.core/empty","clojure.walk/postwalk","f","cljs.core.partial","clojure.walk/prewalk","cljs.core/identity","clojure.walk/keywordize-keys","m","p__8680","vec__8681","cljs.core.nth","k","v","cljs.core.keyword","cljs.core/map?","clojure.walk/stringify-keys","p__8696","vec__8700","cljs.core/Keyword","cljs.core/name","clojure.walk/prewalk-replace","smap","cljs.core/contains?","clojure.walk/postwalk-replace"],"sourcesContent":[";   Copyright (c) Rich Hickey. All rights reserved.\n;   The use and distribution terms for this software are covered by the\n;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)\n;   which can be found in the file epl-v10.html at the root of this distribution.\n;   By using this software in any fashion, you are agreeing to be bound by\n;   the terms of this license.\n;   You must not remove this notice, or any other, from this software.\n\n;;; walk.cljs - generic tree walker with replacement\n\n;; by Stuart Sierra\n;; Jul5 17, 2011\n\n;; CHANGE LOG:\n;;\n;; * July 17, 2011: Port to ClojureScript\n;; \n;; * December 15, 2008: replaced 'walk' with 'prewalk' & 'postwalk'\n;;\n;; * December 9, 2008: first version\n\n\n(ns \n  ^{:author \"Stuart Sierra\",\n     :doc \"This file defines a generic tree walker for Clojure data\nstructures.  It takes any data structure (list, vector, map, set,\nseq), calls a function on every element, and uses the return value\nof the function in place of the original.  This makes it fairly\neasy to write recursive search-and-replace functions, as shown in\nthe examples.\n\nNote: \\\"walk\\\" supports all Clojure data structures EXCEPT maps\ncreated with sorted-map-by.  There is no (obvious) way to retrieve\nthe sorting function.\"}\n  clojure.walk)\n\n(defn walk\n  \"Traverses form, an arbitrary data structure.  inner and outer are\n  functions.  Applies inner to each element of form, building up a\n  data structure of the same type, then applies outer to the result.\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"\n\n  {:added \"1.1\"}\n  [inner outer form]\n  (cond\n    (list? form)      (outer (apply list (map inner form)))\n    (map-entry? form)\n    (outer (MapEntry. (inner (key form)) (inner (val form)) nil))\n    (seq? form)       (outer (doall (map inner form)))\n    (record? form)    (outer (reduce (fn [r x] (conj r (inner x))) form form))\n    (coll? form)      (outer (into (empty form) (map inner form)))\n    :else             (outer form)))\n\n(defn postwalk\n  \"Performs a depth-first, post-order traversal of form.  Calls f on\n  each sub-form, uses f's return value in place of the original.\n  Recognizes all Clojure data structures. Consumes seqs as with doall.\"\n  {:added \"1.1\"}\n  [f form]\n  (walk (partial postwalk f) f form))\n\n(defn prewalk\n  \"Like postwalk, but does pre-order traversal.\"\n  {:added \"1.1\"}\n  [f form]\n  (walk (partial prewalk f) identity (f form)))\n\n(defn keywordize-keys\n  \"Recursively transforms all map keys from strings to keywords.\"\n  {:added \"1.1\"}\n  [m]\n  (let [f (fn [[k v]] (if (string? k) [(keyword k) v] [k v]))]\n    ;; only apply to maps\n    (postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)))\n\n(defn stringify-keys\n  \"Recursively transforms all map keys from keywords to strings.\"\n  {:added \"1.1\"}\n  [m]\n  (let [f (fn [[k v]] (if (keyword? k) [(name k) v] [k v]))]\n    ;; only apply to maps\n    (postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)))\n\n(defn prewalk-replace\n  \"Recursively transforms form by replacing keys in smap with their\n  values.  Like clojure/replace but works on any data structure.  Does\n  replacement at the root of the tree first.\"\n  {:added \"1.1\"}\n  [smap form]\n  (prewalk (fn [x] (if (contains? smap x) (smap x) x)) form))\n\n(defn postwalk-replace\n  \"Recursively transforms form by replacing keys in smap with their\n  values.  Like clojure/replace but works on any data structure.  Does\n  replacement at the leaves of the tree first.\"\n  {:added \"1.1\"}\n  [smap form]\n  (postwalk (fn [x] (if (contains? smap x) (smap x) x)) form))\n"],"x_google_ignoreList":[0]}