@p4ulcristian/iris-layout 0.2.0 → 0.2.2

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

@@ -0,0 +1,158 @@
+import "./cljs_env.js";
+import "./goog.asserts.asserts.js";
+goog.provide("goog.math");
+goog.require("goog.asserts");
+goog.math.randomInt = function(a) {
+  return Math.floor(Math.random() * a);
+};
+goog.math.uniformRandom = function(a, b) {
+  return a + Math.random() * (b - a);
+};
+goog.math.clamp = function(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+};
+goog.math.modulo = function(a, b) {
+  var r = a % b;
+  return r * b < 0 ? r + b : r;
+};
+goog.math.lerp = function(a, b, x) {
+  return a + x * (b - a);
+};
+goog.math.nearlyEquals = function(a, b, opt_tolerance) {
+  return Math.abs(a - b) <= (opt_tolerance || 0.000001);
+};
+goog.math.standardAngle = function(angle) {
+  return goog.math.modulo(angle, 360);
+};
+goog.math.standardAngleInRadians = function(angle) {
+  return goog.math.modulo(angle, 2 * Math.PI);
+};
+goog.math.toRadians = function(angleDegrees) {
+  return angleDegrees * Math.PI / 180;
+};
+goog.math.toDegrees = function(angleRadians) {
+  return angleRadians * 180 / Math.PI;
+};
+goog.math.angleDx = function(degrees, radius) {
+  return radius * Math.cos(goog.math.toRadians(degrees));
+};
+goog.math.angleDy = function(degrees, radius) {
+  return radius * Math.sin(goog.math.toRadians(degrees));
+};
+goog.math.angle = function(x1, y1, x2, y2) {
+  return goog.math.standardAngle(goog.math.toDegrees(Math.atan2(y2 - y1, x2 - x1)));
+};
+goog.math.angleDifference = function(startAngle, endAngle) {
+  var d = goog.math.standardAngle(endAngle) - goog.math.standardAngle(startAngle);
+  if (d > 180) {
+    d = d - 360;
+  } else if (d <= -180) {
+    d = 360 + d;
+  }
+  return d;
+};
+goog.math.sign = function(x) {
+  if (x > 0) {
+    return 1;
+  }
+  if (x < 0) {
+    return -1;
+  }
+  return x;
+};
+goog.math.longestCommonSubsequence = function(array1, array2, opt_compareFn, opt_collectorFn) {
+  var compare = opt_compareFn || function(a, b) {
+    return a == b;
+  };
+  var collect = opt_collectorFn || function(i1, i2) {
+    return array1[i1];
+  };
+  var length1 = array1.length;
+  var length2 = array2.length;
+  var arr = [];
+  var i = 0;
+  for (; i < length1 + 1; i++) {
+    arr[i] = [];
+    arr[i][0] = 0;
+  }
+  var j = 0;
+  for (; j < length2 + 1; j++) {
+    arr[0][j] = 0;
+  }
+  i = 1;
+  for (; i <= length1; i++) {
+    j = 1;
+    for (; j <= length2; j++) {
+      if (compare(array1[i - 1], array2[j - 1])) {
+        arr[i][j] = arr[i - 1][j - 1] + 1;
+      } else {
+        arr[i][j] = Math.max(arr[i - 1][j], arr[i][j - 1]);
+      }
+    }
+  }
+  var result = [];
+  i = length1;
+  j = length2;
+  for (; i > 0 && j > 0;) {
+    if (compare(array1[i - 1], array2[j - 1])) {
+      result.unshift(collect(i - 1, j - 1));
+      i--;
+      j--;
+    } else {
+      if (arr[i - 1][j] > arr[i][j - 1]) {
+        i--;
+      } else {
+        j--;
+      }
+    }
+  }
+  return result;
+};
+goog.math.sum = function(var_args) {
+  return Array.prototype.reduce.call(arguments, function(sum, value) {
+    return sum + value;
+  }, 0);
+};
+goog.math.average = function(var_args) {
+  return goog.math.sum.apply(null, arguments) / arguments.length;
+};
+goog.math.sampleVariance = function(var_args) {
+  var sampleSize = arguments.length;
+  if (sampleSize < 2) {
+    return 0;
+  }
+  var mean = goog.math.average.apply(null, arguments);
+  var variance = goog.math.sum.apply(null, Array.prototype.map.call(arguments, function(val) {
+    return Math.pow(val - mean, 2);
+  })) / (sampleSize - 1);
+  return variance;
+};
+goog.math.standardDeviation = function(var_args) {
+  return Math.sqrt(goog.math.sampleVariance.apply(null, arguments));
+};
+goog.math.isInt = function(num) {
+  return isFinite(num) && num % 1 == 0;
+};
+goog.math.isFiniteNumber = function(num) {
+  return isFinite(num);
+};
+goog.math.isNegativeZero = function(num) {
+  return num == 0 && 1 / num < 0;
+};
+goog.math.log10Floor = function(num) {
+  if (num > 0) {
+    var x = Math.round(Math.log(num) * Math.LOG10E);
+    return x - (parseFloat("1e" + x) > num ? 1 : 0);
+  }
+  return num == 0 ? -Infinity : NaN;
+};
+goog.math.safeFloor = function(num, opt_epsilon) {
+  goog.asserts.assert(opt_epsilon === undefined || opt_epsilon > 0);
+  return Math.floor(num + (opt_epsilon || 2e-15));
+};
+goog.math.safeCeil = function(num, opt_epsilon) {
+  goog.asserts.assert(opt_epsilon === undefined || opt_epsilon > 0);
+  return Math.ceil(num - (opt_epsilon || 2e-15));
+};
+
+//# sourceMappingURL=goog.math.math.js.map

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

@@ -0,0 +1,9 @@
+{
+"version":3,
+"file":"goog.math.math.js",
+"lineCount":155,
+"mappings":"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",
+"sources":["goog/math/math.js"],
+"sourcesContent":["/**\n * @license\n * Copyright The Closure Library Authors.\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @fileoverview Additional mathematical functions.\n */\n\ngoog.provide('goog.math');\n\ngoog.require('goog.asserts');\n\n\n/**\n * Returns a random integer greater than or equal to 0 and less than `a`.\n * @param {number} a  The upper bound for the random integer (exclusive).\n * @return {number} A random integer N such that 0 <= N < a.\n */\ngoog.math.randomInt = function(a) {\n  'use strict';\n  return Math.floor(Math.random() * a);\n};\n\n\n/**\n * Returns a random number greater than or equal to `a` and less than\n * `b`.\n * @param {number} a  The lower bound for the random number (inclusive).\n * @param {number} b  The upper bound for the random number (exclusive).\n * @return {number} A random number N such that a <= N < b.\n */\ngoog.math.uniformRandom = function(a, b) {\n  'use strict';\n  return a + Math.random() * (b - a);\n};\n\n\n/**\n * Takes a number and clamps it to within the provided bounds.\n * @param {number} value The input number.\n * @param {number} min The minimum value to return.\n * @param {number} max The maximum value to return.\n * @return {number} The input number if it is within bounds, or the nearest\n *     number within the bounds.\n */\ngoog.math.clamp = function(value, min, max) {\n  'use strict';\n  return Math.min(Math.max(value, min), max);\n};\n\n\n/**\n * The % operator in JavaScript returns the remainder of a / b, but differs from\n * some other languages in that the result will have the same sign as the\n * dividend. For example, -1 % 8 == -1, whereas in some other languages\n * (such as Python) the result would be 7. This function emulates the more\n * correct modulo behavior, which is useful for certain applications such as\n * calculating an offset index in a circular list.\n *\n * @param {number} a The dividend.\n * @param {number} b The divisor.\n * @return {number} a % b where the result is between 0 and b (either 0 <= x < b\n *     or b < x <= 0, depending on the sign of b).\n */\ngoog.math.modulo = function(a, b) {\n  'use strict';\n  var r = a % b;\n  // If r and b differ in sign, add b to wrap the result to the correct sign.\n  return (r * b < 0) ? r + b : r;\n};\n\n\n/**\n * Performs linear interpolation between values a and b. Returns the value\n * between a and b proportional to x (when x is between 0 and 1. When x is\n * outside this range, the return value is a linear extrapolation).\n * @param {number} a A number.\n * @param {number} b A number.\n * @param {number} x The proportion between a and b.\n * @return {number} The interpolated value between a and b.\n */\ngoog.math.lerp = function(a, b, x) {\n  'use strict';\n  return a + x * (b - a);\n};\n\n\n/**\n * Tests whether the two values are equal to each other, within a certain\n * tolerance to adjust for floating point errors.\n * @param {number} a A number.\n * @param {number} b A number.\n * @param {number=} opt_tolerance Optional tolerance range. Defaults\n *     to 0.000001. If specified, should be greater than 0.\n * @return {boolean} Whether `a` and `b` are nearly equal.\n */\ngoog.math.nearlyEquals = function(a, b, opt_tolerance) {\n  'use strict';\n  return Math.abs(a - b) <= (opt_tolerance || 0.000001);\n};\n\n\n// TODO(user): Rename to normalizeAngle, retaining old name as deprecated\n// alias.\n/**\n * Normalizes an angle to be in range [0-360). Angles outside this range will\n * be normalized to be the equivalent angle with that range.\n * @param {number} angle Angle in degrees.\n * @return {number} Standardized angle.\n */\ngoog.math.standardAngle = function(angle) {\n  'use strict';\n  return goog.math.modulo(angle, 360);\n};\n\n\n/**\n * Normalizes an angle to be in range [0-2*PI). Angles outside this range will\n * be normalized to be the equivalent angle with that range.\n * @param {number} angle Angle in radians.\n * @return {number} Standardized angle.\n */\ngoog.math.standardAngleInRadians = function(angle) {\n  'use strict';\n  return goog.math.modulo(angle, 2 * Math.PI);\n};\n\n\n/**\n * Converts degrees to radians.\n * @param {number} angleDegrees Angle in degrees.\n * @return {number} Angle in radians.\n */\ngoog.math.toRadians = function(angleDegrees) {\n  'use strict';\n  return angleDegrees * Math.PI / 180;\n};\n\n\n/**\n * Converts radians to degrees.\n * @param {number} angleRadians Angle in radians.\n * @return {number} Angle in degrees.\n */\ngoog.math.toDegrees = function(angleRadians) {\n  'use strict';\n  return angleRadians * 180 / Math.PI;\n};\n\n\n/**\n * For a given angle and radius, finds the X portion of the offset.\n * @param {number} degrees Angle in degrees (zero points in +X direction).\n * @param {number} radius Radius.\n * @return {number} The x-distance for the angle and radius.\n */\ngoog.math.angleDx = function(degrees, radius) {\n  'use strict';\n  return radius * Math.cos(goog.math.toRadians(degrees));\n};\n\n\n/**\n * For a given angle and radius, finds the Y portion of the offset.\n * @param {number} degrees Angle in degrees (zero points in +X direction).\n * @param {number} radius Radius.\n * @return {number} The y-distance for the angle and radius.\n */\ngoog.math.angleDy = function(degrees, radius) {\n  'use strict';\n  return radius * Math.sin(goog.math.toRadians(degrees));\n};\n\n\n/**\n * Computes the angle between two points (x1,y1) and (x2,y2).\n * Angle zero points in the +X direction, 90 degrees points in the +Y\n * direction (down) and from there we grow clockwise towards 360 degrees.\n * @param {number} x1 x of first point.\n * @param {number} y1 y of first point.\n * @param {number} x2 x of second point.\n * @param {number} y2 y of second point.\n * @return {number} Standardized angle in degrees of the vector from\n *     x1,y1 to x2,y2.\n */\ngoog.math.angle = function(x1, y1, x2, y2) {\n  'use strict';\n  return goog.math.standardAngle(\n      goog.math.toDegrees(Math.atan2(y2 - y1, x2 - x1)));\n};\n\n\n/**\n * Computes the difference between startAngle and endAngle (angles in degrees).\n * @param {number} startAngle  Start angle in degrees.\n * @param {number} endAngle  End angle in degrees.\n * @return {number} The number of degrees that when added to\n *     startAngle will result in endAngle. Positive numbers mean that the\n *     direction is clockwise. Negative numbers indicate a counter-clockwise\n *     direction.\n *     The shortest route (clockwise vs counter-clockwise) between the angles\n *     is used.\n *     When the difference is 180 degrees, the function returns 180 (not -180)\n *     angleDifference(30, 40) is 10, and angleDifference(40, 30) is -10.\n *     angleDifference(350, 10) is 20, and angleDifference(10, 350) is -20.\n */\ngoog.math.angleDifference = function(startAngle, endAngle) {\n  'use strict';\n  var d =\n      goog.math.standardAngle(endAngle) - goog.math.standardAngle(startAngle);\n  if (d > 180) {\n    d = d - 360;\n  } else if (d <= -180) {\n    d = 360 + d;\n  }\n  return d;\n};\n\n\n/**\n * Returns the sign of a number as per the \"sign\" or \"signum\" function.\n * @param {number} x The number to take the sign of.\n * @return {number} -1 when negative, 1 when positive, 0 when 0. Preserves\n *     signed zeros and NaN.\n */\ngoog.math.sign = function(x) {\n  'use strict';\n  if (x > 0) {\n    return 1;\n  }\n  if (x < 0) {\n    return -1;\n  }\n  return x;  // Preserves signed zeros and NaN.\n};\n\n\n/**\n * JavaScript implementation of Longest Common Subsequence problem.\n * http://en.wikipedia.org/wiki/Longest_common_subsequence\n *\n * Returns the longest possible array that is subarray of both of given arrays.\n *\n * @param {IArrayLike<S>} array1 First array of objects.\n * @param {IArrayLike<T>} array2 Second array of objects.\n * @param {Function=} opt_compareFn Function that acts as a custom comparator\n *     for the array ojects. Function should return true if objects are equal,\n *     otherwise false.\n * @param {Function=} opt_collectorFn Function used to decide what to return\n *     as a result subsequence. It accepts 2 arguments: index of common element\n *     in the first array and index in the second. The default function returns\n *     element from the first array.\n * @return {!Array<S|T>} A list of objects that are common to both arrays\n *     such that there is no common subsequence with size greater than the\n *     length of the list.\n * @template S,T\n */\ngoog.math.longestCommonSubsequence = function(\n    array1, array2, opt_compareFn, opt_collectorFn) {\n  'use strict';\n  var compare = opt_compareFn || function(a, b) {\n    'use strict';\n    return a == b;\n  };\n\n  var collect = opt_collectorFn || function(i1, i2) {\n    'use strict';\n    return array1[i1];\n  };\n\n  var length1 = array1.length;\n  var length2 = array2.length;\n\n  var arr = [];\n  for (var i = 0; i < length1 + 1; i++) {\n    arr[i] = [];\n    arr[i][0] = 0;\n  }\n\n  for (var j = 0; j < length2 + 1; j++) {\n    arr[0][j] = 0;\n  }\n\n  for (i = 1; i <= length1; i++) {\n    for (j = 1; j <= length2; j++) {\n      if (compare(array1[i - 1], array2[j - 1])) {\n        arr[i][j] = arr[i - 1][j - 1] + 1;\n      } else {\n        arr[i][j] = Math.max(arr[i - 1][j], arr[i][j - 1]);\n      }\n    }\n  }\n\n  // Backtracking\n  var result = [];\n  var i = length1, j = length2;\n  while (i > 0 && j > 0) {\n    if (compare(array1[i - 1], array2[j - 1])) {\n      result.unshift(collect(i - 1, j - 1));\n      i--;\n      j--;\n    } else {\n      if (arr[i - 1][j] > arr[i][j - 1]) {\n        i--;\n      } else {\n        j--;\n      }\n    }\n  }\n\n  return result;\n};\n\n\n/**\n * Returns the sum of the arguments.\n * @param {...number} var_args Numbers to add.\n * @return {number} The sum of the arguments (0 if no arguments were provided,\n *     `NaN` if any of the arguments is not a valid number).\n */\ngoog.math.sum = function(var_args) {\n  'use strict';\n  return /** @type {number} */ (\n      Array.prototype.reduce.call(arguments, function(sum, value) {\n        'use strict';\n        return sum + value;\n      }, 0));\n};\n\n\n/**\n * Returns the arithmetic mean of the arguments.\n * @param {...number} var_args Numbers to average.\n * @return {number} The average of the arguments (`NaN` if no arguments\n *     were provided or any of the arguments is not a valid number).\n */\ngoog.math.average = function(var_args) {\n  'use strict';\n  return goog.math.sum.apply(null, arguments) / arguments.length;\n};\n\n\n/**\n * Returns the unbiased sample variance of the arguments. For a definition,\n * see e.g. http://en.wikipedia.org/wiki/Variance\n * @param {...number} var_args Number samples to analyze.\n * @return {number} The unbiased sample variance of the arguments (0 if fewer\n *     than two samples were provided, or `NaN` if any of the samples is\n *     not a valid number).\n */\ngoog.math.sampleVariance = function(var_args) {\n  'use strict';\n  var sampleSize = arguments.length;\n  if (sampleSize < 2) {\n    return 0;\n  }\n\n  var mean = goog.math.average.apply(null, arguments);\n  var variance = goog.math.sum.apply(\n                     null,\n                     Array.prototype.map.call(\n                         arguments,\n                         function(val) {\n                           'use strict';\n                           return Math.pow(val - mean, 2);\n                         })) /\n      (sampleSize - 1);\n\n  return variance;\n};\n\n\n/**\n * Returns the sample standard deviation of the arguments.  For a definition of\n * sample standard deviation, see e.g.\n * http://en.wikipedia.org/wiki/Standard_deviation\n * @param {...number} var_args Number samples to analyze.\n * @return {number} The sample standard deviation of the arguments (0 if fewer\n *     than two samples were provided, or `NaN` if any of the samples is\n *     not a valid number).\n */\ngoog.math.standardDeviation = function(var_args) {\n  'use strict';\n  return Math.sqrt(goog.math.sampleVariance.apply(null, arguments));\n};\n\n\n/**\n * Returns whether the supplied number represents an integer, i.e. that is has\n * no fractional component.  No range-checking is performed on the number.\n * @param {number} num The number to test.\n * @return {boolean} Whether `num` is an integer.\n */\ngoog.math.isInt = function(num) {\n  'use strict';\n  return isFinite(num) && num % 1 == 0;\n};\n\n\n/**\n * Returns whether the supplied number is finite and not NaN.\n * @param {number} num The number to test.\n * @return {boolean} Whether `num` is a finite number.\n * @deprecated Use {@link isFinite} instead.\n */\ngoog.math.isFiniteNumber = function(num) {\n  'use strict';\n  return isFinite(num);\n};\n\n\n/**\n * @param {number} num The number to test.\n * @return {boolean} Whether it is negative zero.\n */\ngoog.math.isNegativeZero = function(num) {\n  'use strict';\n  return num == 0 && 1 / num < 0;\n};\n\n\n/**\n * Returns the precise value of floor(log10(num)).\n * Simpler implementations didn't work because of floating point rounding\n * errors. For example\n * <ul>\n * <li>Math.floor(Math.log(num) / Math.LN10) is off by one for num == 1e+3.\n * <li>Math.floor(Math.log(num) * Math.LOG10E) is off by one for num == 1e+15.\n * <li>Math.floor(Math.log10(num)) is off by one for num == 1e+15 - 1.\n * </ul>\n * @param {number} num A floating point number.\n * @return {number} Its logarithm to base 10 rounded down to the nearest\n *     integer if num > 0. -Infinity if num == 0. NaN if num < 0.\n */\ngoog.math.log10Floor = function(num) {\n  'use strict';\n  if (num > 0) {\n    var x = Math.round(Math.log(num) * Math.LOG10E);\n    return x - (parseFloat('1e' + x) > num ? 1 : 0);\n  }\n  return num == 0 ? -Infinity : NaN;\n};\n\n\n/**\n * A tweaked variant of `Math.floor` which tolerates if the passed number\n * is infinitesimally smaller than the closest integer. It often happens with\n * the results of floating point calculations because of the finite precision\n * of the intermediate results. For example {@code Math.floor(Math.log(1000) /\n * Math.LN10) == 2}, not 3 as one would expect.\n * @param {number} num A number.\n * @param {number=} opt_epsilon An infinitesimally small positive number, the\n *     rounding error to tolerate.\n * @return {number} The largest integer less than or equal to `num`.\n */\ngoog.math.safeFloor = function(num, opt_epsilon) {\n  'use strict';\n  goog.asserts.assert(opt_epsilon === undefined || opt_epsilon > 0);\n  return Math.floor(num + (opt_epsilon || 2e-15));\n};\n\n\n/**\n * A tweaked variant of `Math.ceil`. See `goog.math.safeFloor` for\n * details.\n * @param {number} num A number.\n * @param {number=} opt_epsilon An infinitesimally small positive number, the\n *     rounding error to tolerate.\n * @return {number} The smallest integer greater than or equal to `num`.\n */\ngoog.math.safeCeil = function(num, opt_epsilon) {\n  'use strict';\n  goog.asserts.assert(opt_epsilon === undefined || opt_epsilon > 0);\n  return Math.ceil(num - (opt_epsilon || 2e-15));\n};\n"],
+"names":["goog","provide","require","math","randomInt","goog.math.randomInt","a","Math","floor","random","uniformRandom","goog.math.uniformRandom","b","clamp","goog.math.clamp","value","min","max","modulo","goog.math.modulo","r","lerp","goog.math.lerp","x","nearlyEquals","goog.math.nearlyEquals","opt_tolerance","abs","standardAngle","goog.math.standardAngle","angle","standardAngleInRadians","goog.math.standardAngleInRadians","PI","toRadians","goog.math.toRadians","angleDegrees","toDegrees","goog.math.toDegrees","angleRadians","angleDx","goog.math.angleDx","degrees","radius","cos","angleDy","goog.math.angleDy","sin","goog.math.angle","x1","y1","x2","y2","atan2","angleDifference","goog.math.angleDifference","startAngle","endAngle","d","sign","goog.math.sign","longestCommonSubsequence","goog.math.longestCommonSubsequence","array1","array2","opt_compareFn","opt_collectorFn","compare","collect","i1","i2","length1","length","length2","arr","i","j","result","unshift","sum","goog.math.sum","var_args","Array","prototype","reduce","call","arguments","average","goog.math.average","apply","sampleVariance","goog.math.sampleVariance","sampleSize","mean","variance","map","val","pow","standardDeviation","goog.math.standardDeviation","sqrt","isInt","goog.math.isInt","num","isFinite","isFiniteNumber","goog.math.isFiniteNumber","isNegativeZero","goog.math.isNegativeZero","log10Floor","goog.math.log10Floor","round","log","LOG10E","parseFloat","Infinity","NaN","safeFloor","goog.math.safeFloor","opt_epsilon","asserts","assert","undefined","safeCeil","goog.math.safeCeil","ceil"]
+}

package/dist/cljs-runtime/goog.math.size.js

@@ -0,0 +1,76 @@
+import "./cljs_env.js";
+
+goog.provide("goog.math.Size");
+goog.math.Size = function(width, height) {
+  this.width = width;
+  this.height = height;
+};
+goog.math.Size.equals = function(a, b) {
+  if (a == b) {
+    return true;
+  }
+  if (!a || !b) {
+    return false;
+  }
+  return a.width == b.width && a.height == b.height;
+};
+goog.math.Size.prototype.clone = function() {
+  return new goog.math.Size(this.width, this.height);
+};
+if (goog.DEBUG) {
+  goog.math.Size.prototype.toString = function() {
+    return "(" + this.width + " x " + this.height + ")";
+  };
+}
+goog.math.Size.prototype.getLongest = function() {
+  return Math.max(this.width, this.height);
+};
+goog.math.Size.prototype.getShortest = function() {
+  return Math.min(this.width, this.height);
+};
+goog.math.Size.prototype.area = function() {
+  return this.width * this.height;
+};
+goog.math.Size.prototype.perimeter = function() {
+  return (this.width + this.height) * 2;
+};
+goog.math.Size.prototype.aspectRatio = function() {
+  return this.width / this.height;
+};
+goog.math.Size.prototype.isEmpty = function() {
+  return !this.area();
+};
+goog.math.Size.prototype.ceil = function() {
+  this.width = Math.ceil(this.width);
+  this.height = Math.ceil(this.height);
+  return this;
+};
+goog.math.Size.prototype.fitsInside = function(target) {
+  return this.width <= target.width && this.height <= target.height;
+};
+goog.math.Size.prototype.floor = function() {
+  this.width = Math.floor(this.width);
+  this.height = Math.floor(this.height);
+  return this;
+};
+goog.math.Size.prototype.round = function() {
+  this.width = Math.round(this.width);
+  this.height = Math.round(this.height);
+  return this;
+};
+goog.math.Size.prototype.scale = function(sx, opt_sy) {
+  const sy = typeof opt_sy === "number" ? opt_sy : sx;
+  this.width *= sx;
+  this.height *= sy;
+  return this;
+};
+goog.math.Size.prototype.scaleToCover = function(target) {
+  const s = this.aspectRatio() <= target.aspectRatio() ? target.width / this.width : target.height / this.height;
+  return this.scale(s);
+};
+goog.math.Size.prototype.scaleToFit = function(target) {
+  const s = this.aspectRatio() > target.aspectRatio() ? target.width / this.width : target.height / this.height;
+  return this.scale(s);
+};
+
+//# sourceMappingURL=goog.math.size.js.map

package/dist/cljs-runtime/goog.math.size.js.map

@@ -0,0 +1,9 @@
+{
+"version":3,
+"file":"goog.math.size.js",
+"lineCount":73,
+"mappings":"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",
+"sources":["goog/math/size.js"],
+"sourcesContent":["/**\n * @license\n * Copyright The Closure Library Authors.\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @fileoverview A utility class for representing two-dimensional sizes.\n */\n\n\ngoog.provide('goog.math.Size');\n\n\n\n/**\n * Class for representing sizes consisting of a width and height. Undefined\n * width and height support is deprecated and results in compiler warning.\n * @param {number} width Width.\n * @param {number} height Height.\n * @struct\n * @constructor\n */\ngoog.math.Size = function(width, height) {\n  'use strict';\n  /**\n   * Width\n   * @type {number}\n   */\n  this.width = width;\n\n  /**\n   * Height\n   * @type {number}\n   */\n  this.height = height;\n};\n\n\n/**\n * Compares sizes for equality.\n * @param {goog.math.Size} a A Size.\n * @param {goog.math.Size} b A Size.\n * @return {boolean} True iff the sizes have equal widths and equal\n *     heights, or if both are null.\n */\ngoog.math.Size.equals = function(a, b) {\n  'use strict';\n  if (a == b) {\n    return true;\n  }\n  if (!a || !b) {\n    return false;\n  }\n  return a.width == b.width && a.height == b.height;\n};\n\n\n/**\n * @return {!goog.math.Size} A new copy of the Size.\n */\ngoog.math.Size.prototype.clone = function() {\n  'use strict';\n  return new goog.math.Size(this.width, this.height);\n};\n\n\nif (goog.DEBUG) {\n  /**\n   * Returns a nice string representing size.\n   * @return {string} In the form (50 x 73).\n   * @override\n   */\n  goog.math.Size.prototype.toString = function() {\n    'use strict';\n    return '(' + this.width + ' x ' + this.height + ')';\n  };\n}\n\n\n/**\n * @return {number} The longer of the two dimensions in the size.\n */\ngoog.math.Size.prototype.getLongest = function() {\n  'use strict';\n  return Math.max(this.width, this.height);\n};\n\n\n/**\n * @return {number} The shorter of the two dimensions in the size.\n */\ngoog.math.Size.prototype.getShortest = function() {\n  'use strict';\n  return Math.min(this.width, this.height);\n};\n\n\n/**\n * @return {number} The area of the size (width * height).\n */\ngoog.math.Size.prototype.area = function() {\n  'use strict';\n  return this.width * this.height;\n};\n\n\n/**\n * @return {number} The perimeter of the size (width + height) * 2.\n */\ngoog.math.Size.prototype.perimeter = function() {\n  'use strict';\n  return (this.width + this.height) * 2;\n};\n\n\n/**\n * @return {number} The ratio of the size's width to its height.\n */\ngoog.math.Size.prototype.aspectRatio = function() {\n  'use strict';\n  return this.width / this.height;\n};\n\n\n/**\n * @return {boolean} True if the size has zero area, false if both dimensions\n *     are non-zero numbers.\n */\ngoog.math.Size.prototype.isEmpty = function() {\n  'use strict';\n  return !this.area();\n};\n\n\n/**\n * Clamps the width and height parameters upward to integer values.\n * @return {!goog.math.Size} This size with ceil'd components.\n */\ngoog.math.Size.prototype.ceil = function() {\n  'use strict';\n  this.width = Math.ceil(this.width);\n  this.height = Math.ceil(this.height);\n  return this;\n};\n\n\n/**\n * @param {!goog.math.Size} target The target size.\n * @return {boolean} True if this Size is the same size or smaller than the\n *     target size in both dimensions.\n */\ngoog.math.Size.prototype.fitsInside = function(target) {\n  'use strict';\n  return this.width <= target.width && this.height <= target.height;\n};\n\n\n/**\n * Clamps the width and height parameters downward to integer values.\n * @return {!goog.math.Size} This size with floored components.\n */\ngoog.math.Size.prototype.floor = function() {\n  'use strict';\n  this.width = Math.floor(this.width);\n  this.height = Math.floor(this.height);\n  return this;\n};\n\n\n/**\n * Rounds the width and height parameters to integer values.\n * @return {!goog.math.Size} This size with rounded components.\n */\ngoog.math.Size.prototype.round = function() {\n  'use strict';\n  this.width = Math.round(this.width);\n  this.height = Math.round(this.height);\n  return this;\n};\n\n\n/**\n * Scales this size by the given scale factors. The width and height are scaled\n * by `sx` and `opt_sy` respectively.  If `opt_sy` is not\n * given, then `sx` is used for both the width and height.\n * @param {number} sx The scale factor to use for the width.\n * @param {number=} opt_sy The scale factor to use for the height.\n * @return {!goog.math.Size} This Size object after scaling.\n */\ngoog.math.Size.prototype.scale = function(sx, opt_sy) {\n  'use strict';\n  const sy = (typeof opt_sy === 'number') ? opt_sy : sx;\n  this.width *= sx;\n  this.height *= sy;\n  return this;\n};\n\n\n/**\n * Uniformly scales the size to perfectly cover the dimensions of a given size.\n * If the size is already larger than the target, it will be scaled down to the\n * minimum size at which it still covers the entire target. The original aspect\n * ratio will be preserved.\n *\n * This function assumes that both Sizes contain strictly positive dimensions.\n * @param {!goog.math.Size} target The target size.\n * @return {!goog.math.Size} This Size object, after optional scaling.\n */\ngoog.math.Size.prototype.scaleToCover = function(target) {\n  'use strict';\n  const s = this.aspectRatio() <= target.aspectRatio() ?\n      target.width / this.width :\n      target.height / this.height;\n\n  return this.scale(s);\n};\n\n\n/**\n * Uniformly scales the size to fit inside the dimensions of a given size. The\n * original aspect ratio will be preserved.\n *\n * This function assumes that both Sizes contain strictly positive dimensions.\n * @param {!goog.math.Size} target The target size.\n * @return {!goog.math.Size} This Size object, after optional scaling.\n */\ngoog.math.Size.prototype.scaleToFit = function(target) {\n  'use strict';\n  const s = this.aspectRatio() > target.aspectRatio() ?\n      target.width / this.width :\n      target.height / this.height;\n\n  return this.scale(s);\n};\n"],
+"names":["goog","provide","math","Size","goog.math.Size","width","height","equals","goog.math.Size.equals","a","b","prototype","clone","goog.math.Size.prototype.clone","DEBUG","toString","goog.math.Size.prototype.toString","getLongest","goog.math.Size.prototype.getLongest","Math","max","getShortest","goog.math.Size.prototype.getShortest","min","area","goog.math.Size.prototype.area","perimeter","goog.math.Size.prototype.perimeter","aspectRatio","goog.math.Size.prototype.aspectRatio","isEmpty","goog.math.Size.prototype.isEmpty","ceil","goog.math.Size.prototype.ceil","fitsInside","goog.math.Size.prototype.fitsInside","target","floor","goog.math.Size.prototype.floor","round","goog.math.Size.prototype.round","scale","goog.math.Size.prototype.scale","sx","opt_sy","sy","scaleToCover","goog.math.Size.prototype.scaleToCover","s","scaleToFit","goog.math.Size.prototype.scaleToFit"]
+}

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

@@ -0,0 +1,284 @@
+import "./cljs_env.js";
+
+goog.loadModule(function(exports) {
+  function forEach(obj, f, opt_obj) {
+    for (const key in obj) {
+      f.call(opt_obj, obj[key], key, obj);
+    }
+  }
+  function filter(obj, f, opt_obj) {
+    const res = {};
+    for (const key in obj) {
+      if (f.call(opt_obj, obj[key], key, obj)) {
+        res[key] = obj[key];
+      }
+    }
+    return res;
+  }
+  function map(obj, f, opt_obj) {
+    const res = {};
+    for (const key in obj) {
+      res[key] = f.call(opt_obj, obj[key], key, obj);
+    }
+    return res;
+  }
+  function some(obj, f, opt_obj) {
+    for (const key in obj) {
+      if (f.call(opt_obj, obj[key], key, obj)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function every(obj, f, opt_obj) {
+    for (const key in obj) {
+      if (!f.call(opt_obj, obj[key], key, obj)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function getCount(obj) {
+    let rv = 0;
+    for (const key in obj) {
+      rv++;
+    }
+    return rv;
+  }
+  function getAnyKey(obj) {
+    for (const key in obj) {
+      return key;
+    }
+  }
+  function getAnyValue(obj) {
+    for (const key in obj) {
+      return obj[key];
+    }
+  }
+  function contains(obj, val) {
+    return containsValue(obj, val);
+  }
+  function getValues(obj) {
+    const res = [];
+    let i = 0;
+    for (const key in obj) {
+      res[i++] = obj[key];
+    }
+    return res;
+  }
+  function getKeys(obj) {
+    const res = [];
+    let i = 0;
+    for (const key in obj) {
+      res[i++] = key;
+    }
+    return res;
+  }
+  function getValueByKeys(obj, var_args) {
+    const isArrayLike = goog.isArrayLike(var_args);
+    const keys = isArrayLike ? var_args : arguments;
+    for (let i = isArrayLike ? 0 : 1; i < keys.length; i++) {
+      if (obj == null) {
+        return undefined;
+      }
+      obj = obj[keys[i]];
+    }
+    return obj;
+  }
+  function containsKey(obj, key) {
+    return obj !== null && key in obj;
+  }
+  function containsValue(obj, val) {
+    for (const key in obj) {
+      if (obj[key] == val) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function findKey(obj, f, thisObj = undefined) {
+    for (const key in obj) {
+      if (f.call(thisObj, obj[key], key, obj)) {
+        return key;
+      }
+    }
+    return undefined;
+  }
+  function findValue(obj, f, thisObj = undefined) {
+    const key = findKey(obj, f, thisObj);
+    return key && obj[key];
+  }
+  function isEmpty(obj) {
+    for (const key in obj) {
+      return false;
+    }
+    return true;
+  }
+  function clear(obj) {
+    for (const i in obj) {
+      delete obj[i];
+    }
+  }
+  function remove(obj, key) {
+    let rv;
+    if (rv = key in obj) {
+      delete obj[key];
+    }
+    return rv;
+  }
+  function add(obj, key, val) {
+    if (obj !== null && key in obj) {
+      throw new Error(`The object already contains the key "${key}"`);
+    }
+    set(obj, key, val);
+  }
+  function get(obj, key, val = undefined) {
+    if (obj !== null && key in obj) {
+      return obj[key];
+    }
+    return val;
+  }
+  function set(obj, key, value) {
+    obj[key] = value;
+  }
+  function setIfUndefined(obj, key, value) {
+    return key in obj ? obj[key] : obj[key] = value;
+  }
+  function setWithReturnValueIfNotSet(obj, key, f) {
+    if (key in obj) {
+      return obj[key];
+    }
+    const val = f();
+    obj[key] = val;
+    return val;
+  }
+  function equals(a, b) {
+    for (const k in a) {
+      if (!(k in b) || a[k] !== b[k]) {
+        return false;
+      }
+    }
+    for (const k in b) {
+      if (!(k in a)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function clone(obj) {
+    const res = {};
+    for (const key in obj) {
+      res[key] = obj[key];
+    }
+    return res;
+  }
+  function unsafeClone(obj) {
+    if (!obj || typeof obj !== "object") {
+      return obj;
+    }
+    if (typeof obj.clone === "function") {
+      return obj.clone();
+    }
+    if (typeof Map !== "undefined" && obj instanceof Map) {
+      return new Map(obj);
+    } else if (typeof Set !== "undefined" && obj instanceof Set) {
+      return new Set(obj);
+    } else if (obj instanceof Date) {
+      return new Date(obj.getTime());
+    }
+    const clone = Array.isArray(obj) ? [] : typeof ArrayBuffer === "function" && typeof ArrayBuffer.isView === "function" && ArrayBuffer.isView(obj) && !(obj instanceof DataView) ? new obj.constructor(obj.length) : {};
+    for (const key in obj) {
+      clone[key] = unsafeClone(obj[key]);
+    }
+    return clone;
+  }
+  function transpose(obj) {
+    const transposed = {};
+    for (const key in obj) {
+      transposed[obj[key]] = key;
+    }
+    return transposed;
+  }
+  function extend(target, var_args) {
+    let key;
+    let source;
+    for (let i = 1; i < arguments.length; i++) {
+      source = arguments[i];
+      for (key in source) {
+        target[key] = source[key];
+      }
+      for (let j = 0; j < PROTOTYPE_FIELDS.length; j++) {
+        key = PROTOTYPE_FIELDS[j];
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+  }
+  function create(var_args) {
+    const argLength = arguments.length;
+    if (argLength == 1 && Array.isArray(arguments[0])) {
+      return create.apply(null, arguments[0]);
+    }
+    if (argLength % 2) {
+      throw new Error("Uneven number of arguments");
+    }
+    const rv = {};
+    for (let i = 0; i < argLength; i = i + 2) {
+      rv[arguments[i]] = arguments[i + 1];
+    }
+    return rv;
+  }
+  function createSet(var_args) {
+    const argLength = arguments.length;
+    if (argLength == 1 && Array.isArray(arguments[0])) {
+      return createSet.apply(null, arguments[0]);
+    }
+    const rv = {};
+    for (let i = 0; i < argLength; i++) {
+      rv[arguments[i]] = true;
+    }
+    return rv;
+  }
+  function createImmutableView(obj) {
+    let result = obj;
+    if (Object.isFrozen && !Object.isFrozen(obj)) {
+      result = Object.create(obj);
+      Object.freeze(result);
+    }
+    return result;
+  }
+  function isImmutableView(obj) {
+    return !!Object.isFrozen && Object.isFrozen(obj);
+  }
+  function getAllPropertyNames(obj, includeObjectPrototype = undefined, includeFunctionPrototype = undefined) {
+    if (!obj) {
+      return [];
+    }
+    if (!Object.getOwnPropertyNames || !Object.getPrototypeOf) {
+      return getKeys(obj);
+    }
+    const visitedSet = {};
+    let proto = obj;
+    for (; proto && (proto !== Object.prototype || !!includeObjectPrototype) && (proto !== Function.prototype || !!includeFunctionPrototype);) {
+      const names = Object.getOwnPropertyNames(proto);
+      for (let i = 0; i < names.length; i++) {
+        visitedSet[names[i]] = true;
+      }
+      proto = Object.getPrototypeOf(proto);
+    }
+    return getKeys(visitedSet);
+  }
+  function getSuperClass(constructor) {
+    const proto = Object.getPrototypeOf(constructor.prototype);
+    return proto && proto.constructor;
+  }
+  "use strict";
+  goog.module("goog.object");
+  goog.module.declareLegacyNamespace();
+  const PROTOTYPE_FIELDS = ["constructor", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString", "toString", "valueOf"];
+  exports = {add, clear, clone, contains, containsKey, containsValue, create, createImmutableView, createSet, equals, every, extend, filter, findKey, findValue, forEach, get, getAllPropertyNames, getAnyKey, getAnyValue, getCount, getKeys, getSuperClass, getValueByKeys, getValues, isEmpty, isImmutableView, map, remove, set, setIfUndefined, setWithReturnValueIfNotSet, some, transpose, unsafeClone};
+  return exports;
+});
+
+//# sourceMappingURL=goog.object.object.js.map