@p4ulcristian/iris-layout 0.2.0 → 0.2.2

package/dist/cljs-runtime/goog.object.object.js.map

@@ -0,0 +1,9 @@
+{
+"version":3,
+"file":"goog.object.object.js",
+"lineCount":281,
+"mappings":"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",
+"sources":["goog/object/object.js"],
+"sourcesContent":["/**\n * @license\n * Copyright The Closure Library Authors.\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @fileoverview Utilities for manipulating objects/maps/hashes.\n */\ngoog.module('goog.object');\ngoog.module.declareLegacyNamespace();\n\n/**\n * Calls a function for each element in an object/map/hash.\n * @param {?Object<K,V>} obj The object over which to iterate.\n * @param {function(this:T,V,?,?Object<K,V>):?} f The function to call for every\n *     element. This function takes 3 arguments (the value, the key and the\n *     object) and the return value is ignored.\n * @param {T=} opt_obj This is used as the 'this' object within f.\n * @return {void}\n * @template T,K,V\n */\nfunction forEach(obj, f, opt_obj) {\n  for (const key in obj) {\n    f.call(/** @type {?} */ (opt_obj), obj[key], key, obj);\n  }\n}\n\n/**\n * Calls a function for each element in an object/map/hash. If that call returns\n * true, adds the element to a new object.\n * @param {?Object<K,V>} obj The object over which to iterate.\n * @param {function(this:T,V,?,?Object<K,V>):boolean} f The function to call for\n *     every element. This function takes 3 arguments (the value, the key and\n *     the object) and should return a boolean. If the return value is true the\n *     element is added to the result object. If it is false the element is not\n *     included.\n * @param {T=} opt_obj This is used as the 'this' object within f.\n * @return {!Object<K,V>} a new object in which only elements that passed the\n *     test are present.\n * @template T,K,V\n */\nfunction filter(obj, f, opt_obj) {\n  const res = {};\n  for (const key in obj) {\n    if (f.call(/** @type {?} */ (opt_obj), obj[key], key, obj)) {\n      res[key] = obj[key];\n    }\n  }\n  return res;\n}\n\n/**\n * For every element in an object/map/hash calls a function and inserts the\n * result into a new object.\n * @param {?Object<K,V>} obj The object over which to iterate.\n * @param {function(this:T,V,?,?Object<K,V>):R} f The function to call for every\n *     element. This function takes 3 arguments (the value, the key and the\n *     object) and should return something. The result will be inserted into a\n *     new object.\n * @param {T=} opt_obj This is used as the 'this' object within f.\n * @return {!Object<K,R>} a new object with the results from f.\n * @template T,K,V,R\n */\nfunction map(obj, f, opt_obj) {\n  const res = {};\n  for (const key in obj) {\n    res[key] = f.call(/** @type {?} */ (opt_obj), obj[key], key, obj);\n  }\n  return res;\n}\n\n/**\n * Calls a function for each element in an object/map/hash. If any\n * call returns true, returns true (without checking the rest). If\n * all calls return false, returns false.\n * @param {?Object<K,V>} obj The object to check.\n * @param {function(this:T,V,?,?Object<K,V>):boolean} f The function to call for\n *     every element. This function takes 3 arguments (the value, the key and\n *     the object) and should return a boolean.\n * @param {T=} opt_obj This is used as the 'this' object within f.\n * @return {boolean} true if any element passes the test.\n * @template T,K,V\n */\nfunction some(obj, f, opt_obj) {\n  for (const key in obj) {\n    if (f.call(/** @type {?} */ (opt_obj), obj[key], key, obj)) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Calls a function for each element in an object/map/hash. If\n * all calls return true, returns true. If any call returns false, returns\n * false at this point and does not continue to check the remaining elements.\n * @param {?Object<K,V>} obj The object to check.\n * @param {?function(this:T,V,?,?Object<K,V>):boolean} f The function to call\n *     for every element. This function takes 3 arguments (the value, the key\n *     and the object) and should return a boolean.\n * @param {T=} opt_obj This is used as the 'this' object within f.\n * @return {boolean} false if any element fails the test.\n * @template T,K,V\n */\nfunction every(obj, f, opt_obj) {\n  for (const key in obj) {\n    if (!f.call(/** @type {?} */ (opt_obj), obj[key], key, obj)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Returns the number of key-value pairs in the object map.\n * @param {?Object} obj The object for which to get the number of key-value\n *     pairs.\n * @return {number} The number of key-value pairs in the object map.\n */\nfunction getCount(obj) {\n  let rv = 0;\n  for (const key in obj) {\n    rv++;\n  }\n  return rv;\n}\n\n/**\n * Returns one key from the object map, if any exists.\n * For map literals the returned key will be the first one in most of the\n * browsers (a know exception is Konqueror).\n * @param {?Object} obj The object to pick a key from.\n * @return {string|undefined} The key or undefined if the object is empty.\n */\nfunction getAnyKey(obj) {\n  for (const key in obj) {\n    return key;\n  }\n}\n\n/**\n * Returns one value from the object map, if any exists.\n * For map literals the returned value will be the first one in most of the\n * browsers (a know exception is Konqueror).\n * @param {?Object<K,V>} obj The object to pick a value from.\n * @return {V|undefined} The value or undefined if the object is empty.\n * @template K,V\n */\nfunction getAnyValue(obj) {\n  for (const key in obj) {\n    return obj[key];\n  }\n}\n\n/**\n * Whether the object/hash/map contains the given object as a value.\n * An alias for containsValue(obj, val).\n * @param {?Object<K,V>} obj The object in which to look for val.\n * @param {V} val The object for which to check.\n * @return {boolean} true if val is present.\n * @template K,V\n */\nfunction contains(obj, val) {\n  return containsValue(obj, val);\n}\n\n/**\n * Returns the values of the object/map/hash.\n * @param {?Object<K,V>} obj The object from which to get the values.\n * @return {!Array<V>} The values in the object/map/hash.\n * @template K,V\n */\nfunction getValues(obj) {\n  const res = [];\n  let i = 0;\n  for (const key in obj) {\n    res[i++] = obj[key];\n  }\n  return res;\n}\n\n/**\n * Returns the keys of the object/map/hash.\n * @param {?Object} obj The object from which to get the keys.\n * @return {!Array<string>} Array of property keys.\n */\nfunction getKeys(obj) {\n  const res = [];\n  let i = 0;\n  for (const key in obj) {\n    res[i++] = key;\n  }\n  return res;\n}\n\n/**\n * Get a value from an object multiple levels deep.  This is useful for\n * pulling values from deeply nested objects, such as JSON responses.\n * Example usage: getValueByKeys(jsonObj, 'foo', 'entries', 3)\n * @param {?Object} obj An object to get the value from. Can be array-like.\n * @param {...(string|number|!IArrayLike<number|string>)} var_args A number of\n *     keys (as strings, or numbers, for array-like objects). Can also be\n *     specified as a single array of keys.\n * @return {*} The resulting value. If, at any point, the value for a key in the\n *     current object is null or undefined, returns undefined.\n */\nfunction getValueByKeys(obj, var_args) {\n  const isArrayLike = goog.isArrayLike(var_args);\n  const keys = isArrayLike ?\n      /** @type {!IArrayLike<number|string>} */ (var_args) :\n      arguments;\n\n  // Start with the 2nd parameter for the variable parameters syntax.\n  for (let i = isArrayLike ? 0 : 1; i < keys.length; i++) {\n    if (obj == null) return undefined;\n    obj = obj[keys[i]];\n  }\n\n  return obj;\n}\n\n/**\n * Whether the object/map/hash contains the given key.\n * @param {?Object} obj The object in which to look for key.\n * @param {?} key The key for which to check.\n * @return {boolean} true If the map contains the key.\n */\nfunction containsKey(obj, key) {\n  return obj !== null && key in obj;\n}\n\n/**\n * Whether the object/map/hash contains the given value. This is O(n).\n * @param {?Object<K,V>} obj The object in which to look for val.\n * @param {V} val The value for which to check.\n * @return {boolean} true If the map contains the value.\n * @template K,V\n */\nfunction containsValue(obj, val) {\n  for (const key in obj) {\n    if (obj[key] == val) {\n      return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Searches an object for an element that satisfies the given condition and\n * returns its key.\n * @param {?Object<K,V>} obj The object to search in.\n * @param {function(this:T,V,string,?Object<K,V>):boolean} f The function to\n *     call for every element. Takes 3 arguments (the value, the key and the\n *     object) and should return a boolean.\n * @param {T=} thisObj An optional \"this\" context for the function.\n * @return {string|undefined} The key of an element for which the function\n *     returns true or undefined if no such element is found.\n * @template T,K,V\n */\nfunction findKey(obj, f, thisObj = undefined) {\n  for (const key in obj) {\n    if (f.call(/** @type {?} */ (thisObj), obj[key], key, obj)) {\n      return key;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Searches an object for an element that satisfies the given condition and\n * returns its value.\n * @param {?Object<K,V>} obj The object to search in.\n * @param {function(this:T,V,string,?Object<K,V>):boolean} f The function to\n *     call for every element. Takes 3 arguments (the value, the key and the\n *     object) and should return a boolean.\n * @param {T=} thisObj An optional \"this\" context for the function.\n * @return {V} The value of an element for which the function returns true or\n *     undefined if no such element is found.\n * @template T,K,V\n */\nfunction findValue(obj, f, thisObj = undefined) {\n  const key = findKey(obj, f, thisObj);\n  return key && obj[key];\n}\n\n/**\n * Whether the object/map/hash is empty.\n * @param {?Object} obj The object to test.\n * @return {boolean} true if obj is empty.\n */\nfunction isEmpty(obj) {\n  for (const key in obj) {\n    return false;\n  }\n  return true;\n}\n\n/**\n * Removes all key value pairs from the object/map/hash.\n * @param {?Object} obj The object to clear.\n * @return {void}\n */\nfunction clear(obj) {\n  for (const i in obj) {\n    delete obj[i];\n  }\n}\n\n/**\n * Removes a key-value pair based on the key.\n * @param {?Object} obj The object from which to remove the key.\n * @param {?} key The key to remove.\n * @return {boolean} Whether an element was removed.\n */\nfunction remove(obj, key) {\n  let rv;\n  if (rv = key in /** @type {!Object} */ (obj)) {\n    delete obj[key];\n  }\n  return rv;\n}\n\n/**\n * Adds a key-value pair to the object. Throws an exception if the key is\n * already in use. Use set if you want to change an existing pair.\n * @param {?Object<K,V>} obj The object to which to add the key-value pair.\n * @param {string} key The key to add.\n * @param {V} val The value to add.\n * @return {void}\n * @template K,V\n */\nfunction add(obj, key, val) {\n  if (obj !== null && key in obj) {\n    throw new Error(`The object already contains the key \"${key}\"`);\n  }\n  set(obj, key, val);\n}\n\n/**\n * Returns the value for the given key.\n * @param {?Object<K,V>} obj The object from which to get the value.\n * @param {string} key The key for which to get the value.\n * @param {R=} val The value to return if no item is found for the given key\n *     (default is undefined).\n * @return {V|R|undefined} The value for the given key.\n * @template K,V,R\n */\nfunction get(obj, key, val = undefined) {\n  if (obj !== null && key in obj) {\n    return obj[key];\n  }\n  return val;\n}\n\n/**\n * Adds a key-value pair to the object/map/hash.\n * @param {?Object<K,V>} obj The object to which to add the key-value pair.\n * @param {string} key The key to add.\n * @param {V} value The value to add.\n * @template K,V\n * @return {void}\n */\nfunction set(obj, key, value) {\n  obj[key] = value;\n}\n\n/**\n * Adds a key-value pair to the object/map/hash if it doesn't exist yet.\n * @param {?Object<K,V>} obj The object to which to add the key-value pair.\n * @param {string} key The key to add.\n * @param {V} value The value to add if the key wasn't present.\n * @return {V} The value of the entry at the end of the function.\n * @template K,V\n */\nfunction setIfUndefined(obj, key, value) {\n  return key in /** @type {!Object} */ (obj) ? obj[key] : (obj[key] = value);\n}\n\n/**\n * Sets a key and value to an object if the key is not set. The value will be\n * the return value of the given function. If the key already exists, the\n * object will not be changed and the function will not be called (the function\n * will be lazily evaluated -- only called if necessary).\n * This function is particularly useful when used with an `Object` which is\n * acting as a cache.\n * @param {?Object<K,V>} obj The object to which to add the key-value pair.\n * @param {string} key The key to add.\n * @param {function():V} f The value to add if the key wasn't present.\n * @return {V} The value of the entry at the end of the function.\n * @template K,V\n */\nfunction setWithReturnValueIfNotSet(obj, key, f) {\n  if (key in obj) {\n    return obj[key];\n  }\n\n  const val = f();\n  obj[key] = val;\n  return val;\n}\n\n/**\n * Compares two objects for equality using === on the values.\n * @param {!Object<K,V>} a\n * @param {!Object<K,V>} b\n * @return {boolean}\n * @template K,V\n */\nfunction equals(a, b) {\n  for (const k in a) {\n    if (!(k in b) || a[k] !== b[k]) {\n      return false;\n    }\n  }\n  for (const k in b) {\n    if (!(k in a)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Returns a shallow clone of the object.\n * @param {?Object<K,V>} obj Object to clone.\n * @return {!Object<K,V>} Clone of the input object.\n * @template K,V\n */\nfunction clone(obj) {\n  const res = {};\n  for (const key in obj) {\n    res[key] = obj[key];\n  }\n  return res;\n}\n\n/**\n * Clones a value. The input may be an Object, Array, or basic type. Objects and\n * arrays will be cloned recursively.\n * WARNINGS:\n * <code>unsafeClone</code> does not detect reference loops. Objects\n * that refer to themselves will cause infinite recursion.\n * <code>unsafeClone</code> is unaware of unique identifiers, and\n * copies UIDs created by <code>getUid</code> into cloned results.\n * @param {T} obj The value to clone.\n * @return {T} A clone of the input value.\n * @template T\n */\nfunction unsafeClone(obj) {\n  if (!obj || typeof obj !== 'object') return obj;\n  if (typeof obj.clone === 'function') return obj.clone();\n  if (typeof Map !== 'undefined' && obj instanceof Map) {\n    return new Map(obj);\n  } else if (typeof Set !== 'undefined' && obj instanceof Set) {\n    return new Set(obj);\n  } else if (obj instanceof Date) {\n    return new Date(obj.getTime());\n  }\n  const clone = Array.isArray(obj) ? [] :\n      typeof ArrayBuffer === 'function' &&\n          typeof ArrayBuffer.isView === 'function' && ArrayBuffer.isView(obj) &&\n          !(obj instanceof DataView) ?\n                                     new obj.constructor(obj.length) :\n                                     {};\n  for (const key in obj) {\n    clone[key] = unsafeClone(obj[key]);\n  }\n  return clone;\n}\n\n/**\n * Returns a new object in which all the keys and values are interchanged\n * (keys become values and values become keys). If multiple keys map to the\n * same value, the chosen transposed value is implementation-dependent.\n * @param {?Object} obj The object to transpose.\n * @return {!Object} The transposed object.\n */\nfunction transpose(obj) {\n  const transposed = {};\n  for (const key in obj) {\n    transposed[obj[key]] = key;\n  }\n  return transposed;\n}\n\n/**\n * The names of the fields that are defined on Object.prototype.\n * @type {!Array<string>}\n */\nconst PROTOTYPE_FIELDS = [\n  'constructor',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n  'toString',\n  'valueOf',\n];\n\n/**\n * Extends an object with another object.\n * This operates 'in-place'; it does not create a new Object.\n * Example:\n * var o = {};\n * extend(o, {a: 0, b: 1});\n * o; // {a: 0, b: 1}\n * extend(o, {b: 2, c: 3});\n * o; // {a: 0, b: 2, c: 3}\n * @param {?Object} target The object to modify. Existing properties will be\n *     overwritten if they are also present in one of the objects in `var_args`.\n * @param {...(?Object|undefined)} var_args The objects from which values\n *     will be copied.\n * @return {void}\n * @deprecated Prefer Object.assign\n */\nfunction extend(target, var_args) {\n  let key;\n  let source;\n  for (let i = 1; i < arguments.length; i++) {\n    source = arguments[i];\n    for (key in source) {\n      target[key] = source[key];\n    }\n\n    // For IE the for-in-loop does not contain any properties that are not\n    // enumerable on the prototype object (for example isPrototypeOf from\n    // Object.prototype) and it will also not include 'replace' on objects that\n    // extend String and change 'replace' (not that it is common for anyone to\n    // extend anything except Object).\n\n    for (let j = 0; j < PROTOTYPE_FIELDS.length; j++) {\n      key = PROTOTYPE_FIELDS[j];\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n}\n\n/**\n * Creates a new object built from the key-value pairs provided as arguments.\n * @param {...*} var_args If only one argument is provided and it is an array\n *     then this is used as the arguments, otherwise even arguments are used as\n *     the property names and odd arguments are used as the property values.\n * @return {!Object} The new object.\n * @throws {!Error} If there are uneven number of arguments or there is only one\n *     non array argument.\n */\nfunction create(var_args) {\n  const argLength = arguments.length;\n  if (argLength == 1 && Array.isArray(arguments[0])) {\n    return create.apply(null, arguments[0]);\n  }\n\n  if (argLength % 2) {\n    throw new Error('Uneven number of arguments');\n  }\n\n  const rv = {};\n  for (let i = 0; i < argLength; i += 2) {\n    rv[arguments[i]] = arguments[i + 1];\n  }\n  return rv;\n}\n\n/**\n * Creates a new object where the property names come from the arguments but\n * the value is always set to true\n * @param {...*} var_args If only one argument is provided and it is an array\n *     then this is used as the arguments, otherwise the arguments are used as\n *     the property names.\n * @return {!Object} The new object.\n */\nfunction createSet(var_args) {\n  const argLength = arguments.length;\n  if (argLength == 1 && Array.isArray(arguments[0])) {\n    return createSet.apply(null, arguments[0]);\n  }\n\n  const rv = {};\n  for (let i = 0; i < argLength; i++) {\n    rv[arguments[i]] = true;\n  }\n  return rv;\n}\n\n/**\n * Creates an immutable view of the underlying object, if the browser\n * supports immutable objects.\n * In default mode, writes to this view will fail silently. In strict mode,\n * they will throw an error.\n * @param {!Object<K,V>} obj An object.\n * @return {!Object<K,V>} An immutable view of that object, or the original\n *     object if this browser does not support immutables.\n * @template K,V\n */\nfunction createImmutableView(obj) {\n  let result = obj;\n  if (Object.isFrozen && !Object.isFrozen(obj)) {\n    result = Object.create(obj);\n    Object.freeze(result);\n  }\n  return result;\n}\n\n/**\n * @param {!Object} obj An object.\n * @return {boolean} Whether this is an immutable view of the object.\n */\nfunction isImmutableView(obj) {\n  return !!Object.isFrozen && Object.isFrozen(obj);\n}\n\n/**\n * Get all properties names on a given Object regardless of enumerability.\n * <p> If the browser does not support `Object.getOwnPropertyNames` nor\n * `Object.getPrototypeOf` then this is equivalent to using\n * `getKeys`\n * @param {?Object} obj The object to get the properties of.\n * @param {boolean=} includeObjectPrototype Whether properties defined on\n *     `Object.prototype` should be included in the result.\n * @param {boolean=} includeFunctionPrototype Whether properties defined on\n *     `Function.prototype` should be included in the result.\n * @return {!Array<string>}\n * @public\n */\nfunction getAllPropertyNames(\n    obj, includeObjectPrototype = undefined,\n    includeFunctionPrototype = undefined) {\n  if (!obj) {\n    return [];\n  }\n\n  // Naively use a for..in loop to get the property names if the browser doesn't\n  // support any other APIs for getting it.\n  if (!Object.getOwnPropertyNames || !Object.getPrototypeOf) {\n    return getKeys(obj);\n  }\n\n  const visitedSet = {};\n\n  // Traverse the prototype chain and add all properties to the visited set.\n  let proto = obj;\n  while (proto && (proto !== Object.prototype || !!includeObjectPrototype) &&\n         (proto !== Function.prototype || !!includeFunctionPrototype)) {\n    const names = Object.getOwnPropertyNames(proto);\n    for (let i = 0; i < names.length; i++) {\n      visitedSet[names[i]] = true;\n    }\n    proto = Object.getPrototypeOf(proto);\n  }\n\n  return getKeys(visitedSet);\n}\n\n/**\n * Given a ES5 or ES6 class reference, return its super class / super\n * constructor.\n * This should be used in rare cases where you need to walk up the inheritance\n * tree (this is generally a bad idea). But this work with ES5 and ES6 classes,\n * unlike relying on the superClass_ property.\n * Note: To start walking up the hierarchy from an instance call this with its\n * `constructor` property; e.g. `getSuperClass(instance.constructor)`.\n * @param {function(new: ?)} constructor\n * @return {?Object}\n */\nfunction getSuperClass(constructor) {\n  const proto = Object.getPrototypeOf(constructor.prototype);\n  return proto && proto.constructor;\n}\n\nexports = {\n  add,\n  clear,\n  clone,\n  contains,\n  containsKey,\n  containsValue,\n  create,\n  createImmutableView,\n  createSet,\n  equals,\n  every,\n  extend,\n  filter,\n  findKey,\n  findValue,\n  forEach,\n  get,\n  getAllPropertyNames,\n  getAnyKey,\n  getAnyValue,\n  getCount,\n  getKeys,\n  getSuperClass,\n  getValueByKeys,\n  getValues,\n  isEmpty,\n  isImmutableView,\n  map,\n  remove,\n  set,\n  setIfUndefined,\n  setWithReturnValueIfNotSet,\n  some,\n  transpose,\n  unsafeClone,\n};\n"],
+"names":["forEach","obj","f","opt_obj","key","call","filter","res","map","some","every","getCount","rv","getAnyKey","getAnyValue","contains","val","containsValue","getValues","i","getKeys","getValueByKeys","var_args","isArrayLike","goog","keys","arguments","length","undefined","containsKey","findKey","thisObj","findValue","isEmpty","clear","remove","add","Error","set","get","value","setIfUndefined","setWithReturnValueIfNotSet","equals","a","b","k","clone","unsafeClone","Map","Set","Date","getTime","Array","isArray","ArrayBuffer","isView","DataView","constructor","transpose","transposed","extend","target","source","j","PROTOTYPE_FIELDS","Object","prototype","hasOwnProperty","create","argLength","apply","createSet","createImmutableView","result","isFrozen","freeze","isImmutableView","getAllPropertyNames","includeObjectPrototype","includeFunctionPrototype","getOwnPropertyNames","getPrototypeOf","visitedSet","proto","Function","names","getSuperClass","module","declareLegacyNamespace","exports"]
+}

package/dist/cljs-runtime/goog.reflect.reflect.js

@@ -0,0 +1,32 @@
+import "./cljs_env.js";
+
+goog.provide("goog.reflect");
+goog.reflect.object = function(type, object) {
+  return object;
+};
+goog.reflect.objectProperty = function(prop, object) {
+  return prop;
+};
+goog.reflect.sinkValue = function(x) {
+  goog.reflect.sinkValue[" "](x);
+  return x;
+};
+goog.reflect.sinkValue[" "] = function() {
+};
+goog.reflect.canAccessProperty = function(obj, prop) {
+  try {
+    goog.reflect.sinkValue(obj[prop]);
+    return true;
+  } catch (e) {
+  }
+  return false;
+};
+goog.reflect.cache = function(cacheObj, key, valueFn, opt_keyFn) {
+  const storedKey = opt_keyFn ? opt_keyFn(key) : key;
+  if (Object.prototype.hasOwnProperty.call(cacheObj, storedKey)) {
+    return cacheObj[storedKey];
+  }
+  return cacheObj[storedKey] = valueFn(key);
+};
+
+//# sourceMappingURL=goog.reflect.reflect.js.map

package/dist/cljs-runtime/goog.reflect.reflect.js.map

@@ -0,0 +1,9 @@
+{
+"version":3,
+"file":"goog.reflect.reflect.js",
+"lineCount":29,
+"mappings":"AAUAA,IAAKC,CAAAA,OAAL,CAAa,cAAb,CAAA;AAeAD,IAAKE,CAAAA,OAAQC,CAAAA,MAAb,GAAsBC,QAAQ,CAACC,IAAD,EAAOF,MAAP,CAAe;AAE3C,SAAOA,MAAP;AAF2C,CAA7C;AAqBAH,IAAKE,CAAAA,OAAQI,CAAAA,cAAb,GAA8BC,QAAQ,CAACC,IAAD,EAAOL,MAAP,CAAe;AAEnD,SAAOK,IAAP;AAFmD,CAArD;AAgBAR,IAAKE,CAAAA,OAAQO,CAAAA,SAAb,GAAyBC,QAAQ,CAACC,CAAD,CAAI;AAEnCX,MAAKE,CAAAA,OAAQO,CAAAA,SAAb,CAAuB,GAAvB,CAAA,CAA4BE,CAA5B,CAAA;AACA,SAAOA,CAAP;AAHmC,CAArC;AAWAX,IAAKE,CAAAA,OAAQO,CAAAA,SAAb,CAAuB,GAAvB,CAAA,GAA8B,QAAQ,EAAG;CAAzC;AAUAT,IAAKE,CAAAA,OAAQU,CAAAA,iBAAb,GAAiCC,QAAQ,CAACC,GAAD,EAAMN,IAAN,CAAY;AAEnD,KAAI;AACFR,QAAKE,CAAAA,OAAQO,CAAAA,SAAb,CAAuBK,GAAA,CAAIN,IAAJ,CAAvB,CAAA;AACA,WAAO,IAAP;AAFE,GAGF,QAAOO,CAAP,CAAU;;AAEZ,SAAO,KAAP;AAPmD,CAArD;AAuCAf,IAAKE,CAAAA,OAAQc,CAAAA,KAAb,GAAqBC,QAAQ,CAACC,QAAD,EAAWC,GAAX,EAAgBC,OAAhB,EAAyBC,SAAzB,CAAoC;AAE/D,QAAMC,YAAYD,SAAA,GAAYA,SAAA,CAAUF,GAAV,CAAZ,GAA6BA,GAA/C;AAEA,MAAII,MAAOC,CAAAA,SAAUC,CAAAA,cAAeC,CAAAA,IAAhC,CAAqCR,QAArC,EAA+CI,SAA/C,CAAJ;AACE,WAAOJ,QAAA,CAASI,SAAT,CAAP;AADF;AAIA,SAAQJ,QAAA,CAASI,SAAT,CAAR,GAA8BF,OAAA,CAAQD,GAAR,CAA9B;AAR+D,CAAjE;;",
+"sources":["goog/reflect/reflect.js"],
+"sourcesContent":["/**\n * @license\n * Copyright The Closure Library Authors.\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @fileoverview Useful compiler idioms.\n */\n\ngoog.provide('goog.reflect');\n\n\n/**\n * Syntax for object literal casts.\n * @see http://go/jscompiler-renaming\n * @see https://goo.gl/CRs09P\n *\n * Use this if you have an object literal whose keys need to have the same names\n * as the properties of some class even after they are renamed by the compiler.\n *\n * @param {!Function} type Type to cast to.\n * @param {Object} object Object literal to cast.\n * @return {Object} The object literal.\n */\ngoog.reflect.object = function(type, object) {\n  'use strict';\n  return object;\n};\n\n/**\n * Syntax for renaming property strings.\n * @see http://go/jscompiler-renaming\n * @see https://goo.gl/CRs09P\n *\n * Use this if you have an need to access a property as a string, but want\n * to also have the property renamed by the compiler. In contrast to\n * goog.reflect.object, this method takes an instance of an object.\n *\n * Properties must be simple names (not qualified names).\n *\n * @param {string} prop Name of the property\n * @param {!Object} object Instance of the object whose type will be used\n *     for renaming\n * @return {string} The renamed property.\n */\ngoog.reflect.objectProperty = function(prop, object) {\n  'use strict';\n  return prop;\n};\n\n/**\n * To assert to the compiler that an operation is needed when it would\n * otherwise be stripped. For example:\n * <code>\n *     // Force a layout\n *     goog.reflect.sinkValue(dialog.offsetHeight);\n * </code>\n * @param {T} x\n * @return {T}\n * @template T\n */\ngoog.reflect.sinkValue = function(x) {\n  'use strict';\n  goog.reflect.sinkValue[' '](x);\n  return x;\n};\n\n\n/**\n * The compiler should optimize this function away iff no one ever uses\n * goog.reflect.sinkValue.\n */\ngoog.reflect.sinkValue[' '] = function() {};\n\n\n/**\n * Check if a property can be accessed without throwing an exception.\n * @param {Object} obj The owner of the property.\n * @param {string} prop The property name.\n * @return {boolean} Whether the property is accessible. Will also return true\n *     if obj is null.\n */\ngoog.reflect.canAccessProperty = function(obj, prop) {\n  'use strict';\n  try {\n    goog.reflect.sinkValue(obj[prop]);\n    return true;\n  } catch (e) {\n  }\n  return false;\n};\n\n\n/**\n * Retrieves a value from a cache given a key. The compiler provides special\n * consideration for this call such that it is generally considered side-effect\n * free. However, if the `opt_keyFn` or `valueFn` have side-effects\n * then the entire call is considered to have side-effects.\n *\n * Conventionally storing the value on the cache would be considered a\n * side-effect and preclude unused calls from being pruned, ie. even if\n * the value was never used, it would still always be stored in the cache.\n *\n * Providing a side-effect free `valueFn` and `opt_keyFn`\n * allows unused calls to `goog.reflect.cache` to be pruned.\n *\n * @param {!Object<K, V>} cacheObj The object that contains the cached values.\n * @param {?} key The key to lookup in the cache. If it is not string or number\n *     then a `opt_keyFn` should be provided. The key is also used as the\n *     parameter to the `valueFn`.\n * @param {function(?):V} valueFn The value provider to use to calculate the\n *     value to store in the cache. This function should be side-effect free\n *     to take advantage of the optimization.\n * @param {function(?):K=} opt_keyFn The key provider to determine the cache\n *     map key. This should be used if the given key is not a string or number.\n *     If not provided then the given key is used. This function should be\n *     side-effect free to take advantage of the optimization.\n * @return {V} The cached or calculated value.\n * @template K\n * @template V\n */\ngoog.reflect.cache = function(cacheObj, key, valueFn, opt_keyFn) {\n  'use strict';\n  const storedKey = opt_keyFn ? opt_keyFn(key) : key;\n\n  if (Object.prototype.hasOwnProperty.call(cacheObj, storedKey)) {\n    return cacheObj[storedKey];\n  }\n\n  return (cacheObj[storedKey] = valueFn(key));\n};\n"],
+"names":["goog","provide","reflect","object","goog.reflect.object","type","objectProperty","goog.reflect.objectProperty","prop","sinkValue","goog.reflect.sinkValue","x","canAccessProperty","goog.reflect.canAccessProperty","obj","e","cache","goog.reflect.cache","cacheObj","key","valueFn","opt_keyFn","storedKey","Object","prototype","hasOwnProperty","call"]
+}

package/dist/cljs-runtime/goog.string.const.js

@@ -0,0 +1,35 @@
+import "./cljs_env.js";
+import "./goog.asserts.asserts.js";
+import "./goog.string.typedstring.js";
+goog.provide("goog.string.Const");
+goog.require("goog.asserts");
+goog.require("goog.string.TypedString");
+goog.string.Const = function(opt_token, opt_content) {
+  this.stringConstValueWithSecurityContract__googStringSecurityPrivate_ = opt_token === goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_ && opt_content || "";
+  this.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_ = goog.string.Const.TYPE_MARKER_;
+};
+goog.string.Const.prototype.implementsGoogStringTypedString = true;
+goog.string.Const.prototype.getTypedStringValue = function() {
+  return this.stringConstValueWithSecurityContract__googStringSecurityPrivate_;
+};
+if (goog.DEBUG) {
+  goog.string.Const.prototype.toString = function() {
+    return "Const{" + this.stringConstValueWithSecurityContract__googStringSecurityPrivate_ + "}";
+  };
+}
+goog.string.Const.unwrap = function(stringConst) {
+  if (stringConst instanceof goog.string.Const && stringConst.constructor === goog.string.Const && stringConst.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_ === goog.string.Const.TYPE_MARKER_) {
+    return stringConst.stringConstValueWithSecurityContract__googStringSecurityPrivate_;
+  } else {
+    goog.asserts.fail("expected object of type Const, got '" + stringConst + "'");
+    return "type_error:Const";
+  }
+};
+goog.string.Const.from = function(s) {
+  return new goog.string.Const(goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_, s);
+};
+goog.string.Const.TYPE_MARKER_ = {};
+goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_ = {};
+goog.string.Const.EMPTY = goog.string.Const.from("");
+
+//# sourceMappingURL=goog.string.const.js.map

package/dist/cljs-runtime/goog.string.const.js.map

@@ -0,0 +1,9 @@
+{
+"version":3,
+"file":"goog.string.const.js",
+"lineCount":31,
+"mappings":"AAMAA,IAAKC,CAAAA,OAAL,CAAa,mBAAb,CAAA;AAEAD,IAAKE,CAAAA,OAAL,CAAa,cAAb,CAAA;AACAF,IAAKE,CAAAA,OAAL,CAAa,yBAAb,CAAA;AAgCAF,IAAKG,CAAAA,MAAOC,CAAAA,KAAZ,GAAoBC,QAAQ,CAACC,SAAD,EAAYC,WAAZ,CAAyB;AAQnD,MAAKC,CAAAA,gEAAL,GACMF,SADN,KAEMN,IAAKG,CAAAA,MAAOC,CAAAA,KAAMK,CAAAA,sCAFxB,IAGKF,WAHL,IAII,EAJJ;AAYA,MAAKG,CAAAA,uDAAL,GACIV,IAAKG,CAAAA,MAAOC,CAAAA,KAAMO,CAAAA,YADtB;AApBmD,CAArD;AA6BAX,IAAKG,CAAAA,MAAOC,CAAAA,KAAMQ,CAAAA,SAAUC,CAAAA,+BAA5B,GAA8D,IAA9D;AAcAb,IAAKG,CAAAA,MAAOC,CAAAA,KAAMQ,CAAAA,SAAUE,CAAAA,mBAA5B,GAAkDC,QAAQ,EAAG;AAE3D,SAAO,IAAKP,CAAAA,gEAAZ;AAF2D,CAA7D;AAMA,IAAIR,IAAKgB,CAAAA,KAAT;AAWEhB,MAAKG,CAAAA,MAAOC,CAAAA,KAAMQ,CAAAA,SAAUK,CAAAA,QAA5B,GAAuCC,QAAQ,EAAG;AAEhD,WAAO,QAAP,GACI,IAAKV,CAAAA,gEADT,GAEI,GAFJ;AAFgD,GAAlD;AAXF;AA6BAR,IAAKG,CAAAA,MAAOC,CAAAA,KAAMe,CAAAA,MAAlB,GAA2BC,QAAQ,CAACC,WAAD,CAAc;AAM/C,MAAIA,WAAJ,YAA2BrB,IAAKG,CAAAA,MAAOC,CAAAA,KAAvC,IACIiB,WAAYC,CAAAA,WADhB,KACgCtB,IAAKG,CAAAA,MAAOC,CAAAA,KAD5C,IAEIiB,WAAYX,CAAAA,uDAFhB,KAGQV,IAAKG,CAAAA,MAAOC,CAAAA,KAAMO,CAAAA,YAH1B;AAIE,WAAOU,WACFb,CAAAA,gEADL;AAJF,QAMO;AACLR,QAAKuB,CAAAA,OAAQC,CAAAA,IAAb,CACI,sCADJ,GAC8CH,WAD9C,GAC4D,GAD5D,CAAA;AAEA,WAAO,kBAAP;AAHK;AAZwC,CAAjD;AAyCArB,IAAKG,CAAAA,MAAOC,CAAAA,KAAMqB,CAAAA,IAAlB,GAAyBC,QAAQ,CAACC,CAAD,CAAI;AAEnC,SAAO,IAAI3B,IAAKG,CAAAA,MAAOC,CAAAA,KAAhB,CACHJ,IAAKG,CAAAA,MAAOC,CAAAA,KAAMK,CAAAA,sCADf,EACuDkB,CADvD,CAAP;AAFmC,CAArC;AAYA3B,IAAKG,CAAAA,MAAOC,CAAAA,KAAMO,CAAAA,YAAlB,GAAiC,EAAjC;AAOAX,IAAKG,CAAAA,MAAOC,CAAAA,KAAMK,CAAAA,sCAAlB,GAA2D,EAA3D;AAMAT,IAAKG,CAAAA,MAAOC,CAAAA,KAAMwB,CAAAA,KAAlB,GAA0B5B,IAAKG,CAAAA,MAAOC,CAAAA,KAAMqB,CAAAA,IAAlB,CAAuB,EAAvB,CAA1B;;",
+"sources":["goog/string/const.js"],
+"sourcesContent":["/**\n * @license\n * Copyright The Closure Library Authors.\n * SPDX-License-Identifier: Apache-2.0\n */\n\ngoog.provide('goog.string.Const');\n\ngoog.require('goog.asserts');\ngoog.require('goog.string.TypedString');\n\n\n\n/**\n * Wrapper for compile-time-constant strings.\n *\n * Const is a wrapper for strings that can only be created from program\n * constants (i.e., string literals).  This property relies on a custom Closure\n * compiler check that `goog.string.Const.from` is only invoked on\n * compile-time-constant expressions.\n *\n * Const is useful in APIs whose correct and secure use requires that certain\n * arguments are not attacker controlled: Compile-time constants are inherently\n * under the control of the application and not under control of external\n * attackers, and hence are safe to use in such contexts.\n *\n * Instances of this type must be created via its factory method\n * `goog.string.Const.from` and not by invoking its constructor.  The\n * constructor intentionally takes no parameters and the type is immutable;\n * hence only a default instance corresponding to the empty string can be\n * obtained via constructor invocation.  Use goog.string.Const.EMPTY\n * instead of using this constructor to get an empty Const string.\n *\n * @see goog.string.Const#from\n * @constructor\n * @final\n * @struct\n * @implements {goog.string.TypedString}\n * @param {Object=} opt_token package-internal implementation detail.\n * @param {string=} opt_content package-internal implementation detail.\n */\ngoog.string.Const = function(opt_token, opt_content) {\n  'use strict';\n  /**\n   * The wrapped value of this Const object.  The field has a purposely ugly\n   * name to make (non-compiled) code that attempts to directly access this\n   * field stand out.\n   * @private {string}\n   */\n  this.stringConstValueWithSecurityContract__googStringSecurityPrivate_ =\n      ((opt_token ===\n        goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_) &&\n       opt_content) ||\n      '';\n\n  /**\n   * A type marker used to implement additional run-time type checking.\n   * @see goog.string.Const#unwrap\n   * @const {!Object}\n   * @private\n   */\n  this.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_ =\n      goog.string.Const.TYPE_MARKER_;\n};\n\n\n/**\n * @override\n * @const\n */\ngoog.string.Const.prototype.implementsGoogStringTypedString = true;\n\n\n/**\n * Returns this Const's value as a string.\n *\n * IMPORTANT: In code where it is security-relevant that an object's type is\n * indeed `goog.string.Const`, use `goog.string.Const.unwrap`\n * instead of this method.\n *\n * @see goog.string.Const#unwrap\n * @override\n * @return {string}\n */\ngoog.string.Const.prototype.getTypedStringValue = function() {\n  'use strict';\n  return this.stringConstValueWithSecurityContract__googStringSecurityPrivate_;\n};\n\n\nif (goog.DEBUG) {\n  /**\n   * Returns a debug-string representation of this value.\n   *\n   * To obtain the actual string value wrapped inside an object of this type,\n   * use `goog.string.Const.unwrap`.\n   *\n   * @see goog.string.Const#unwrap\n   * @override\n   * @return {string}\n   */\n  goog.string.Const.prototype.toString = function() {\n    'use strict';\n    return 'Const{' +\n        this.stringConstValueWithSecurityContract__googStringSecurityPrivate_ +\n        '}';\n  };\n}\n\n\n/**\n * Performs a runtime check that the provided object is indeed an instance\n * of `goog.string.Const`, and returns its value.\n * @param {!goog.string.Const} stringConst The object to extract from.\n * @return {string} The Const object's contained string, unless the run-time\n *     type check fails. In that case, `unwrap` returns an innocuous\n *     string, or, if assertions are enabled, throws\n *     `goog.asserts.AssertionError`.\n */\ngoog.string.Const.unwrap = function(stringConst) {\n  'use strict';\n  // Perform additional run-time type-checking to ensure that stringConst is\n  // indeed an instance of the expected type.  This provides some additional\n  // protection against security bugs due to application code that disables type\n  // checks.\n  if (stringConst instanceof goog.string.Const &&\n      stringConst.constructor === goog.string.Const &&\n      stringConst.STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_ ===\n          goog.string.Const.TYPE_MARKER_) {\n    return stringConst\n        .stringConstValueWithSecurityContract__googStringSecurityPrivate_;\n  } else {\n    goog.asserts.fail(\n        'expected object of type Const, got \\'' + stringConst + '\\'');\n    return 'type_error:Const';\n  }\n};\n\n\n/**\n * Creates a Const object from a compile-time constant string.\n *\n * It is illegal to invoke this function on an expression whose\n * compile-time-constant value cannot be determined by the Closure compiler.\n *\n * Correct invocations include,\n * <pre>\n *   var s = goog.string.Const.from('hello');\n *   var t = goog.string.Const.from('hello' + 'world');\n * </pre>\n *\n * In contrast, the following are illegal:\n * <pre>\n *   var s = goog.string.Const.from(getHello());\n *   var t = goog.string.Const.from('hello' + world);\n * </pre>\n *\n * @param {string} s A constant string from which to create a Const.\n * @return {!goog.string.Const} A Const object initialized to stringConst.\n */\ngoog.string.Const.from = function(s) {\n  'use strict';\n  return new goog.string.Const(\n      goog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_, s);\n};\n\n/**\n * Type marker for the Const type, used to implement additional run-time\n * type checking.\n * @const {!Object}\n * @private\n */\ngoog.string.Const.TYPE_MARKER_ = {};\n\n/**\n * @type {!Object}\n * @private\n * @const\n */\ngoog.string.Const.GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_ = {};\n\n/**\n * A Const instance wrapping the empty string.\n * @const {!goog.string.Const}\n */\ngoog.string.Const.EMPTY = goog.string.Const.from('');\n"],
+"names":["goog","provide","require","string","Const","goog.string.Const","opt_token","opt_content","stringConstValueWithSecurityContract__googStringSecurityPrivate_","GOOG_STRING_CONSTRUCTOR_TOKEN_PRIVATE_","STRING_CONST_TYPE_MARKER__GOOG_STRING_SECURITY_PRIVATE_","TYPE_MARKER_","prototype","implementsGoogStringTypedString","getTypedStringValue","goog.string.Const.prototype.getTypedStringValue","DEBUG","toString","goog.string.Const.prototype.toString","unwrap","goog.string.Const.unwrap","stringConst","constructor","asserts","fail","from","goog.string.Const.from","s","EMPTY"]
+}

package/dist/cljs-runtime/goog.string.internal.js

@@ -0,0 +1,119 @@
+import "./cljs_env.js";
+
+goog.provide("goog.string.internal");
+goog.string.internal.startsWith = function(str, prefix) {
+  return str.lastIndexOf(prefix, 0) == 0;
+};
+goog.string.internal.endsWith = function(str, suffix) {
+  const l = str.length - suffix.length;
+  return l >= 0 && str.indexOf(suffix, l) == l;
+};
+goog.string.internal.caseInsensitiveStartsWith = function(str, prefix) {
+  return goog.string.internal.caseInsensitiveCompare(prefix, str.slice(0, prefix.length)) == 0;
+};
+goog.string.internal.caseInsensitiveEndsWith = function(str, suffix) {
+  return goog.string.internal.caseInsensitiveCompare(suffix, str.slice(str.length - suffix.length)) == 0;
+};
+goog.string.internal.caseInsensitiveEquals = function(str1, str2) {
+  return str1.toLowerCase() == str2.toLowerCase();
+};
+goog.string.internal.isEmptyOrWhitespace = function(str) {
+  return /^[\s\xa0]*$/.test(str);
+};
+goog.string.internal.trim = goog.TRUSTED_SITE && String.prototype.trim ? function(str) {
+  return str.trim();
+} : function(str) {
+  return /^[\s\xa0]*([\s\S]*?)[\s\xa0]*$/.exec(str)[1];
+};
+goog.string.internal.caseInsensitiveCompare = function(str1, str2) {
+  const test1 = String(str1).toLowerCase();
+  const test2 = String(str2).toLowerCase();
+  if (test1 < test2) {
+    return -1;
+  } else if (test1 == test2) {
+    return 0;
+  } else {
+    return 1;
+  }
+};
+goog.string.internal.newLineToBr = function(str, opt_xml) {
+  return str.replace(/(\r\n|\r|\n)/g, opt_xml ? "\x3cbr /\x3e" : "\x3cbr\x3e");
+};
+goog.string.internal.htmlEscape = function(str, opt_isLikelyToContainHtmlChars) {
+  if (opt_isLikelyToContainHtmlChars) {
+    str = str.replace(goog.string.internal.AMP_RE_, "\x26amp;").replace(goog.string.internal.LT_RE_, "\x26lt;").replace(goog.string.internal.GT_RE_, "\x26gt;").replace(goog.string.internal.QUOT_RE_, "\x26quot;").replace(goog.string.internal.SINGLE_QUOTE_RE_, "\x26#39;").replace(goog.string.internal.NULL_RE_, "\x26#0;");
+    return str;
+  } else {
+    if (!goog.string.internal.ALL_RE_.test(str)) {
+      return str;
+    }
+    if (str.indexOf("\x26") != -1) {
+      str = str.replace(goog.string.internal.AMP_RE_, "\x26amp;");
+    }
+    if (str.indexOf("\x3c") != -1) {
+      str = str.replace(goog.string.internal.LT_RE_, "\x26lt;");
+    }
+    if (str.indexOf("\x3e") != -1) {
+      str = str.replace(goog.string.internal.GT_RE_, "\x26gt;");
+    }
+    if (str.indexOf('"') != -1) {
+      str = str.replace(goog.string.internal.QUOT_RE_, "\x26quot;");
+    }
+    if (str.indexOf("'") != -1) {
+      str = str.replace(goog.string.internal.SINGLE_QUOTE_RE_, "\x26#39;");
+    }
+    if (str.indexOf("\x00") != -1) {
+      str = str.replace(goog.string.internal.NULL_RE_, "\x26#0;");
+    }
+    return str;
+  }
+};
+goog.string.internal.AMP_RE_ = /&/g;
+goog.string.internal.LT_RE_ = /</g;
+goog.string.internal.GT_RE_ = />/g;
+goog.string.internal.QUOT_RE_ = /"/g;
+goog.string.internal.SINGLE_QUOTE_RE_ = /'/g;
+goog.string.internal.NULL_RE_ = /\x00/g;
+goog.string.internal.ALL_RE_ = /[\x00&<>"']/;
+goog.string.internal.whitespaceEscape = function(str, opt_xml) {
+  return goog.string.internal.newLineToBr(str.replace(/  /g, " \x26#160;"), opt_xml);
+};
+goog.string.internal.contains = function(str, subString) {
+  return str.indexOf(subString) != -1;
+};
+goog.string.internal.caseInsensitiveContains = function(str, subString) {
+  return goog.string.internal.contains(str.toLowerCase(), subString.toLowerCase());
+};
+goog.string.internal.compareVersions = function(version1, version2) {
+  let order = 0;
+  const v1Subs = goog.string.internal.trim(String(version1)).split(".");
+  const v2Subs = goog.string.internal.trim(String(version2)).split(".");
+  const subCount = Math.max(v1Subs.length, v2Subs.length);
+  for (let subIdx = 0; order == 0 && subIdx < subCount; subIdx++) {
+    let v1Sub = v1Subs[subIdx] || "";
+    let v2Sub = v2Subs[subIdx] || "";
+    do {
+      const v1Comp = /(\d*)(\D*)(.*)/.exec(v1Sub) || ["", "", "", ""];
+      const v2Comp = /(\d*)(\D*)(.*)/.exec(v2Sub) || ["", "", "", ""];
+      if (v1Comp[0].length == 0 && v2Comp[0].length == 0) {
+        break;
+      }
+      const v1CompNum = v1Comp[1].length == 0 ? 0 : parseInt(v1Comp[1], 10);
+      const v2CompNum = v2Comp[1].length == 0 ? 0 : parseInt(v2Comp[1], 10);
+      order = goog.string.internal.compareElements_(v1CompNum, v2CompNum) || goog.string.internal.compareElements_(v1Comp[2].length == 0, v2Comp[2].length == 0) || goog.string.internal.compareElements_(v1Comp[2], v2Comp[2]);
+      v1Sub = v1Comp[3];
+      v2Sub = v2Comp[3];
+    } while (order == 0);
+  }
+  return order;
+};
+goog.string.internal.compareElements_ = function(left, right) {
+  if (left < right) {
+    return -1;
+  } else if (left > right) {
+    return 1;
+  }
+  return 0;
+};
+
+//# sourceMappingURL=goog.string.internal.js.map

package/dist/cljs-runtime/goog.string.internal.js.map

@@ -0,0 +1,9 @@
+{
+"version":3,
+"file":"goog.string.internal.js",
+"lineCount":116,
+"mappings":"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",
+"sources":["goog/string/internal.js"],
+"sourcesContent":["/**\n * @license\n * Copyright The Closure Library Authors.\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @fileoverview String functions called from Closure packages that couldn't\n * depend on each other. Outside Closure, use goog.string function which\n * delegate to these.\n */\n\n\ngoog.provide('goog.string.internal');\n\n\n/**\n * Fast prefix-checker.\n * @param {string} str The string to check.\n * @param {string} prefix A string to look for at the start of `str`.\n * @return {boolean} True if `str` begins with `prefix`.\n * @see goog.string.startsWith\n */\ngoog.string.internal.startsWith = function(str, prefix) {\n  'use strict';\n  return str.lastIndexOf(prefix, 0) == 0;\n};\n\n\n/**\n * Fast suffix-checker.\n * @param {string} str The string to check.\n * @param {string} suffix A string to look for at the end of `str`.\n * @return {boolean} True if `str` ends with `suffix`.\n * @see goog.string.endsWith\n */\ngoog.string.internal.endsWith = function(str, suffix) {\n  'use strict';\n  const l = str.length - suffix.length;\n  return l >= 0 && str.indexOf(suffix, l) == l;\n};\n\n\n/**\n * Case-insensitive prefix-checker.\n * @param {string} str The string to check.\n * @param {string} prefix  A string to look for at the end of `str`.\n * @return {boolean} True if `str` begins with `prefix` (ignoring\n *     case).\n * @see goog.string.caseInsensitiveStartsWith\n */\ngoog.string.internal.caseInsensitiveStartsWith = function(str, prefix) {\n  'use strict';\n  return (\n      goog.string.internal.caseInsensitiveCompare(\n          prefix, str.slice(0, prefix.length)) == 0);\n};\n\n\n/**\n * Case-insensitive suffix-checker.\n * @param {string} str The string to check.\n * @param {string} suffix A string to look for at the end of `str`.\n * @return {boolean} True if `str` ends with `suffix` (ignoring\n *     case).\n * @see goog.string.caseInsensitiveEndsWith\n */\ngoog.string.internal.caseInsensitiveEndsWith = function(str, suffix) {\n  'use strict';\n  return (\n      goog.string.internal.caseInsensitiveCompare(\n          suffix, str.slice(str.length - suffix.length)) == 0);\n};\n\n\n/**\n * Case-insensitive equality checker.\n * @param {string} str1 First string to check.\n * @param {string} str2 Second string to check.\n * @return {boolean} True if `str1` and `str2` are the same string,\n *     ignoring case.\n * @see goog.string.caseInsensitiveEquals\n */\ngoog.string.internal.caseInsensitiveEquals = function(str1, str2) {\n  'use strict';\n  return str1.toLowerCase() == str2.toLowerCase();\n};\n\n\n/**\n * Checks if a string is empty or contains only whitespaces.\n * @param {string} str The string to check.\n * @return {boolean} Whether `str` is empty or whitespace only.\n * @see goog.string.isEmptyOrWhitespace\n */\ngoog.string.internal.isEmptyOrWhitespace = function(str) {\n  'use strict';\n  // testing length == 0 first is actually slower in all browsers (about the\n  // same in Opera).\n  // Since IE doesn't include non-breaking-space (0xa0) in their \\s character\n  // class (as required by section 7.2 of the ECMAScript spec), we explicitly\n  // include it in the regexp to enforce consistent cross-browser behavior.\n  return /^[\\s\\xa0]*$/.test(str);\n};\n\n\n/**\n * Trims white spaces to the left and right of a string.\n * @param {string} str The string to trim.\n * @return {string} A trimmed copy of `str`.\n */\ngoog.string.internal.trim =\n    (goog.TRUSTED_SITE && String.prototype.trim) ? function(str) {\n      'use strict';\n      return str.trim();\n    } : function(str) {\n      'use strict';\n      // Since IE doesn't include non-breaking-space (0xa0) in their \\s\n      // character class (as required by section 7.2 of the ECMAScript spec),\n      // we explicitly include it in the regexp to enforce consistent\n      // cross-browser behavior.\n      // NOTE: We don't use String#replace because it might have side effects\n      // causing this function to not compile to 0 bytes.\n      return /^[\\s\\xa0]*([\\s\\S]*?)[\\s\\xa0]*$/.exec(str)[1];\n    };\n\n\n/**\n * A string comparator that ignores case.\n * -1 = str1 less than str2\n *  0 = str1 equals str2\n *  1 = str1 greater than str2\n *\n * @param {string} str1 The string to compare.\n * @param {string} str2 The string to compare `str1` to.\n * @return {number} The comparator result, as described above.\n * @see goog.string.caseInsensitiveCompare\n */\ngoog.string.internal.caseInsensitiveCompare = function(str1, str2) {\n  'use strict';\n  const test1 = String(str1).toLowerCase();\n  const test2 = String(str2).toLowerCase();\n\n  if (test1 < test2) {\n    return -1;\n  } else if (test1 == test2) {\n    return 0;\n  } else {\n    return 1;\n  }\n};\n\n\n/**\n * Converts \\n to <br>s or <br />s.\n * @param {string} str The string in which to convert newlines.\n * @param {boolean=} opt_xml Whether to use XML compatible tags.\n * @return {string} A copy of `str` with converted newlines.\n * @see goog.string.newLineToBr\n */\ngoog.string.internal.newLineToBr = function(str, opt_xml) {\n  'use strict';\n  return str.replace(/(\\r\\n|\\r|\\n)/g, opt_xml ? '<br />' : '<br>');\n};\n\n\n/**\n * Escapes double quote '\"' and single quote '\\'' characters in addition to\n * '&', '<', and '>' so that a string can be included in an HTML tag attribute\n * value within double or single quotes.\n * @param {string} str string to be escaped.\n * @param {boolean=} opt_isLikelyToContainHtmlChars\n * @return {string} An escaped copy of `str`.\n * @see goog.string.htmlEscape\n */\ngoog.string.internal.htmlEscape = function(\n    str, opt_isLikelyToContainHtmlChars) {\n  'use strict';\n  if (opt_isLikelyToContainHtmlChars) {\n    str = str.replace(goog.string.internal.AMP_RE_, '&amp;')\n              .replace(goog.string.internal.LT_RE_, '&lt;')\n              .replace(goog.string.internal.GT_RE_, '&gt;')\n              .replace(goog.string.internal.QUOT_RE_, '&quot;')\n              .replace(goog.string.internal.SINGLE_QUOTE_RE_, '&#39;')\n              .replace(goog.string.internal.NULL_RE_, '&#0;');\n    return str;\n\n  } else {\n    // quick test helps in the case when there are no chars to replace, in\n    // worst case this makes barely a difference to the time taken\n    if (!goog.string.internal.ALL_RE_.test(str)) return str;\n\n    // str.indexOf is faster than regex.test in this case\n    if (str.indexOf('&') != -1) {\n      str = str.replace(goog.string.internal.AMP_RE_, '&amp;');\n    }\n    if (str.indexOf('<') != -1) {\n      str = str.replace(goog.string.internal.LT_RE_, '&lt;');\n    }\n    if (str.indexOf('>') != -1) {\n      str = str.replace(goog.string.internal.GT_RE_, '&gt;');\n    }\n    if (str.indexOf('\"') != -1) {\n      str = str.replace(goog.string.internal.QUOT_RE_, '&quot;');\n    }\n    if (str.indexOf('\\'') != -1) {\n      str = str.replace(goog.string.internal.SINGLE_QUOTE_RE_, '&#39;');\n    }\n    if (str.indexOf('\\x00') != -1) {\n      str = str.replace(goog.string.internal.NULL_RE_, '&#0;');\n    }\n    return str;\n  }\n};\n\n\n/**\n * Regular expression that matches an ampersand, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.AMP_RE_ = /&/g;\n\n\n/**\n * Regular expression that matches a less than sign, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.LT_RE_ = /</g;\n\n\n/**\n * Regular expression that matches a greater than sign, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.GT_RE_ = />/g;\n\n\n/**\n * Regular expression that matches a double quote, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.QUOT_RE_ = /\"/g;\n\n\n/**\n * Regular expression that matches a single quote, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.SINGLE_QUOTE_RE_ = /'/g;\n\n\n/**\n * Regular expression that matches null character, for use in escaping.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.NULL_RE_ = /\\x00/g;\n\n\n/**\n * Regular expression that matches any character that needs to be escaped.\n * @const {!RegExp}\n * @private\n */\ngoog.string.internal.ALL_RE_ = /[\\x00&<>\"']/;\n\n\n/**\n * Do escaping of whitespace to preserve spatial formatting. We use character\n * entity #160 to make it safer for xml.\n * @param {string} str The string in which to escape whitespace.\n * @param {boolean=} opt_xml Whether to use XML compatible tags.\n * @return {string} An escaped copy of `str`.\n * @see goog.string.whitespaceEscape\n */\ngoog.string.internal.whitespaceEscape = function(str, opt_xml) {\n  'use strict';\n  // This doesn't use goog.string.preserveSpaces for backwards compatibility.\n  return goog.string.internal.newLineToBr(\n      str.replace(/  /g, ' &#160;'), opt_xml);\n};\n\n\n/**\n * Determines whether a string contains a substring.\n * @param {string} str The string to search.\n * @param {string} subString The substring to search for.\n * @return {boolean} Whether `str` contains `subString`.\n * @see goog.string.contains\n */\ngoog.string.internal.contains = function(str, subString) {\n  'use strict';\n  return str.indexOf(subString) != -1;\n};\n\n\n/**\n * Determines whether a string contains a substring, ignoring case.\n * @param {string} str The string to search.\n * @param {string} subString The substring to search for.\n * @return {boolean} Whether `str` contains `subString`.\n * @see goog.string.caseInsensitiveContains\n */\ngoog.string.internal.caseInsensitiveContains = function(str, subString) {\n  'use strict';\n  return goog.string.internal.contains(\n      str.toLowerCase(), subString.toLowerCase());\n};\n\n\n/**\n * Compares two version numbers.\n *\n * @param {string|number} version1 Version of first item.\n * @param {string|number} version2 Version of second item.\n *\n * @return {number}  1 if `version1` is higher.\n *                   0 if arguments are equal.\n *                  -1 if `version2` is higher.\n * @see goog.string.compareVersions\n */\ngoog.string.internal.compareVersions = function(version1, version2) {\n  'use strict';\n  let order = 0;\n  // Trim leading and trailing whitespace and split the versions into\n  // subversions.\n  const v1Subs = goog.string.internal.trim(String(version1)).split('.');\n  const v2Subs = goog.string.internal.trim(String(version2)).split('.');\n  const subCount = Math.max(v1Subs.length, v2Subs.length);\n\n  // Iterate over the subversions, as long as they appear to be equivalent.\n  for (let subIdx = 0; order == 0 && subIdx < subCount; subIdx++) {\n    let v1Sub = v1Subs[subIdx] || '';\n    let v2Sub = v2Subs[subIdx] || '';\n\n    do {\n      // Split the subversions into pairs of numbers and qualifiers (like 'b').\n      // Two different RegExp objects are use to make it clear the code\n      // is side-effect free\n      const v1Comp = /(\\d*)(\\D*)(.*)/.exec(v1Sub) || ['', '', '', ''];\n      const v2Comp = /(\\d*)(\\D*)(.*)/.exec(v2Sub) || ['', '', '', ''];\n      // Break if there are no more matches.\n      if (v1Comp[0].length == 0 && v2Comp[0].length == 0) {\n        break;\n      }\n\n      // Parse the numeric part of the subversion. A missing number is\n      // equivalent to 0.\n      const v1CompNum = v1Comp[1].length == 0 ? 0 : parseInt(v1Comp[1], 10);\n      const v2CompNum = v2Comp[1].length == 0 ? 0 : parseInt(v2Comp[1], 10);\n\n      // Compare the subversion components. The number has the highest\n      // precedence. Next, if the numbers are equal, a subversion without any\n      // qualifier is always higher than a subversion with any qualifier. Next,\n      // the qualifiers are compared as strings.\n      order = goog.string.internal.compareElements_(v1CompNum, v2CompNum) ||\n          goog.string.internal.compareElements_(\n              v1Comp[2].length == 0, v2Comp[2].length == 0) ||\n          goog.string.internal.compareElements_(v1Comp[2], v2Comp[2]);\n      // Stop as soon as an inequality is discovered.\n\n      v1Sub = v1Comp[3];\n      v2Sub = v2Comp[3];\n    } while (order == 0);\n  }\n\n  return order;\n};\n\n\n/**\n * Compares elements of a version number.\n *\n * @param {string|number|boolean} left An element from a version number.\n * @param {string|number|boolean} right An element from a version number.\n *\n * @return {number}  1 if `left` is higher.\n *                   0 if arguments are equal.\n *                  -1 if `right` is higher.\n * @private\n */\ngoog.string.internal.compareElements_ = function(left, right) {\n  'use strict';\n  if (left < right) {\n    return -1;\n  } else if (left > right) {\n    return 1;\n  }\n  return 0;\n};\n"],
+"names":["goog","provide","string","internal","startsWith","goog.string.internal.startsWith","str","prefix","lastIndexOf","endsWith","goog.string.internal.endsWith","suffix","l","length","indexOf","caseInsensitiveStartsWith","goog.string.internal.caseInsensitiveStartsWith","caseInsensitiveCompare","slice","caseInsensitiveEndsWith","goog.string.internal.caseInsensitiveEndsWith","caseInsensitiveEquals","goog.string.internal.caseInsensitiveEquals","str1","str2","toLowerCase","isEmptyOrWhitespace","goog.string.internal.isEmptyOrWhitespace","test","trim","TRUSTED_SITE","String","prototype","exec","goog.string.internal.caseInsensitiveCompare","test1","test2","newLineToBr","goog.string.internal.newLineToBr","opt_xml","replace","htmlEscape","goog.string.internal.htmlEscape","opt_isLikelyToContainHtmlChars","AMP_RE_","LT_RE_","GT_RE_","QUOT_RE_","SINGLE_QUOTE_RE_","NULL_RE_","ALL_RE_","whitespaceEscape","goog.string.internal.whitespaceEscape","contains","goog.string.internal.contains","subString","caseInsensitiveContains","goog.string.internal.caseInsensitiveContains","compareVersions","goog.string.internal.compareVersions","version1","version2","order","v1Subs","split","v2Subs","subCount","Math","max","subIdx","v1Sub","v2Sub","v1Comp","v2Comp","v1CompNum","parseInt","v2CompNum","compareElements_","goog.string.internal.compareElements_","left","right"]
+}