ramda-adjunct 2.34.0

package/es/spreadPath.js

@@ -0,0 +1,25 @@
+import { curryN, converge, merge, dissocPath, pathOr } from 'ramda';
+/**
+ * Spreads object under property path onto provided object.
+ * It's like {@link RA.flattenPath|flattenPath}, but removes object under the property path.
+ *
+ * @func spreadPath
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
+ * @category Object
+ * @typedef Idx = String | Int
+ * @sig [Idx] -> {k: v} -> {k: v}
+ * @param {!Array.<string|number>} path The property path to spread
+ * @param {!Object} obj The provided object
+ * @return {!Object} The result of the spread
+ * @see {@link RA.spreadProp|spreadProp}, {@link RA.flattenPath|flattenPath}
+ * @example
+ *
+ * RA.spreadPath(
+ *   ['b1', 'b2'],
+ *   { a: 1, b1: { b2: { c: 3, d: 4 } } }
+ * ); // => { a: 1, c: 3, d: 4, b1: {} };
+ */
+
+var spreadPath = curryN(2, converge(merge, [dissocPath, pathOr({})]));
+export default spreadPath;

package/es/spreadProp.js

@@ -0,0 +1,25 @@
+import { of, curry } from 'ramda';
+import spreadPath from './spreadPath';
+/**
+ * Spreads object under property onto provided object.
+ * It's like {@link RA.flattenProp|flattenProp}, but removes object under the property.
+ *
+ * @func spreadProp
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.19.0|v1.19.0}
+ * @category Object
+ * @typedef Idx = String | Int
+ * @sig Idx -> {k: v} -> {k: v}
+ * @param {!string|number} prop The property to spread
+ * @param {!Object} obj The provided object
+ * @return {!Object} The result of the spread
+ * @see {@link RA.spreadPath|spreadPath}, {@link RA.flattenProp|flattenProp}
+ * @example
+ *
+ * RA.spreadProp('b', { a: 1, b: { c: 3, d: 4 } }); // => { a: 1, c: 3, d: 4 };
+ */
+
+var spreadProp = curry(function (prop, obj) {
+  return spreadPath(of(prop), obj);
+});
+export default spreadProp;

package/es/stubArray.js

@@ -0,0 +1,19 @@
+/**
+ * A function that returns new empty array on every call.
+ *
+ * @func stubArray
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
+ * @category Function
+ * @sig ... -> Array
+ * @return {Array} New empty array
+ * @example
+ *
+ * RA.stubArray(); //=> []
+ * RA.stubArray(1, 2, 3); //=> []
+ */
+var stubArray = function stubArray() {
+  return [];
+};
+
+export default stubArray;

package/es/stubNull.js

@@ -0,0 +1,18 @@
+import { always } from 'ramda';
+/**
+ * A function that returns `null`.
+ *
+ * @func stubNull
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.6.0|v1.6.0}
+ * @category Function
+ * @sig ... -> null
+ * @return {null}
+ * @example
+ *
+ * RA.stubNull(); //=> null
+ * RA.stubNull(1, 2, 3); //=> null
+ */
+
+var stubNull = always(null);
+export default stubNull;

package/es/stubObj.js

@@ -0,0 +1,20 @@
+/**
+ * This function returns a new empty object.
+ *
+ * @func stubObj
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
+ * @category Function
+ * @sig ... -> Object
+ * @aliases stubObject
+ * @return {Object} Returns the new empty object.
+ * @example
+ *
+ * RA.stubObj(); //=> {}
+ * RA.stubObj(1, 2, 3); //=> {}
+ */
+var stubObj = function stubObj() {
+  return {};
+};
+
+export default stubObj;

package/es/stubString.js

@@ -0,0 +1,18 @@
+import { always } from 'ramda';
+/**
+ * A function that returns empty string.
+ *
+ * @func stubString
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.1.0|v2.1.0}
+ * @category Function
+ * @sig ... -> String
+ * @return {string} The empty string
+ * @example
+ *
+ * RA.stubString(); //=> ''
+ * RA.stubString(1, 2, 3); //=> ''
+ */
+
+var stubString = always('');
+export default stubString;

package/es/stubUndefined.js

@@ -0,0 +1,19 @@
+import { always } from 'ramda';
+/**
+ * A function that returns `undefined`.
+ *
+ * @func stubUndefined
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.0.0|v1.0.0}
+ * @category Function
+ * @sig ... -> undefined
+ * @return {undefined}
+ * @example
+ *
+ * RA.stubUndefined(); //=> undefined
+ * RA.stubUndefined(1, 2, 3); //=> undefined
+ */
+
+var stubUndefined = always(void 0); // eslint-disable-line no-void
+
+export default stubUndefined;

package/es/subtractNum.js

@@ -0,0 +1,19 @@
+import { flip, subtract } from 'ramda';
+/**
+ * Subtracts its first argument from its second argument.
+ *
+ * @func subtractNum
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category Math
+ * @sig Number -> Number -> Number
+ * @param {number} subtrahend the number to subtract
+ * @param {number} minuend the number to subtract from
+ * @return {number} A number representing the difference of subtracting the subtrahend from the minuend
+ * @example
+ *
+ * RA.subtractNum(3, 5); //=> 2
+ */
+
+var subtractNum = flip(subtract);
+export default subtractNum;

package/es/thenCatchP.js

@@ -0,0 +1,26 @@
+import { invoker } from 'ramda';
+/**
+ * Composable shortcut for `Promise.then` that allows for success and failure callbacks.
+ * The thenCatchP function returns a Promise. It takes three arguments: a callback function for the success of the Promise,
+ * a callback function for the failure of the Promise, and the promise instance itself.
+ *
+ * @func thenCatchP
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.27.0|v2.27.0}
+ * @category Function
+ * @sig (a -> b) -> (c -> d) -> Promise a -> Promise b | d
+ * @param {Function} onFulfilled A Function called if the Promise is fulfilled. This function has one argument, the fulfillment value
+ * @param {Function} onRejected A Function called if the Promise is rejected. This function has one argument, the error
+ * @param {Promise} promise Any Promise or Thenable object
+ * @return {Promise}
+ * @see {@link RA.resolveP|resolveP}, {@link RA.rejectP|rejectP}, {@link RA.allP|allP}
+ * @example
+ *
+ * const promise = Promise.resolve(1);
+ * const add1 = x => x + 1;
+ *
+ * RA.thenCatchP(add1, console.error, promise); // => Promise(2)
+ */
+
+export var thenCatchP = invoker(2, 'then');
+export default thenCatchP;

package/es/thenP.js

@@ -0,0 +1,28 @@
+import { invoker } from 'ramda';
+/**
+ * Composable shortcut for `Promise.then`.
+ * The thenP function returns a Promise. It takes two arguments: a callback function for the success of the Promise
+ * and the promise instance itself.
+ *
+ * @func thenP
+ * @memberOf RA
+ * @aliases then
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.8.0|v2.8.0}
+ * @deprecated since v2.12.0; available in ramda@0.26.0 as R.then
+ * @category Function
+ * @sig (a -> Promise b | b) -> Promise b
+ * @param {Function} onFulfilled A Function called if the Promise is fulfilled. This function has one argument, the fulfillment value
+ * @param {Promise} promise Any Promise or Thenable object
+ * @return {Promise} A Promise in the pending status
+
+ * @see {@link RA.resolveP|resolveP}, {@link RA.rejectP|rejectP}, {@link RA.allP|allP}
+ * @example
+ *
+ * const promise = Promise.resolve(1);
+ * const add1 = v => v + 1;
+ *
+ * RA.thenP(add1, promise); // => Promise(2)
+ */
+
+var thenP = invoker(1, 'then');
+export default thenP;

package/es/toArray.js

@@ -0,0 +1,27 @@
+import { ifElse, values, curryN } from 'ramda';
+import isIterable from './isIterable';
+import isFunction from './isFunction';
+import ponyfill from './internal/ponyfills/Array.from';
+export var fromPonyfill = curryN(1, ponyfill);
+var fromArray = isFunction(Array.from) ? curryN(1, Array.from) : fromPonyfill;
+/**
+ * Converts value to an array.
+ *
+ * @func toArray
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category List
+ * @sig * -> [a]
+ * @param {*} val The value to convert
+ * @return {Array}
+ * @example
+ *
+ * RA.toArray([1, 2]); //=> [1, 2]
+ * RA.toArray({'foo': 1, 'bar': 2}); //=> [1, 2]
+ * RA.toArray('abc'); //=> ['a', 'b', 'c']
+ * RA.toArray(1); //=> []
+ * RA.toArray(null); //=> []
+ */
+
+var toArray = ifElse(isIterable, fromArray, values);
+export default toArray;

package/es/toInteger32.js

@@ -0,0 +1,24 @@
+import { curryN } from 'ramda';
+/**
+ * Converts double-precision 64-bit binary format IEEE 754 to signed 32 bit integer number.
+ *
+ * @func toInteger32
+ * @aliases toInt32
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.28.0|v2.28.0}
+ * @category Math
+ * @sig Number -> Number
+ * @param {number} number A number
+ * @return {number} A signed 32-bit integer number
+ * @see {@link RA.toUInteger32|toUInteger32}, {@link http://speakingjs.com/es5/ch11.html#integers_via_bitwise_operators}
+ * @example
+ *
+ * RA.toInteger32(2 ** 35); // => 0
+ * RA.toInteger32(2 ** 30); // => 1073741824
+ */
+// eslint-disable-next-line no-bitwise
+
+var toInteger32 = curryN(1, function (val) {
+  return val >> 0;
+});
+export default toInteger32;

package/es/toUinteger32.js

@@ -0,0 +1,26 @@
+import { curryN } from 'ramda';
+/**
+ * Converts double-precision 64-bit binary format IEEE 754 to unsigned 32 bit integer number.
+ *
+ * @func toUinteger32
+ * @aliases toUint32
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.28.0|v2.28.0}
+ * @category Math
+ * @sig Number -> Number
+ * @param {number} val Value to be converted.
+ * @return {number}
+ * @see {@link RA.toInteger32|toInteger32}, {@link http://speakingjs.com/es5/ch11.html#integers_via_bitwise_operators}
+ * @example
+ *
+ * RA.toUinteger32(1.5); //=> 1
+ * RA.toInteger32(2 ** 35); // => 0
+ * RA.toInteger32(2 ** 31); // => 2147483648
+ * RA.toInteger32(2 ** 30); // => 1073741824
+ */
+// eslint-disable-next-line no-bitwise
+
+var toUinteger32 = curryN(1, function (val) {
+  return val >>> 0;
+});
+export default toUinteger32;

package/es/trimCharsEnd.js

@@ -0,0 +1,22 @@
+import { curry, dropLastWhile, join, pipe, split } from 'ramda';
+import contained from './contained';
+/**
+ * Removes specified characters from the end of a string.
+ *
+ * @func trimCharsEnd
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.25.0|v2.25.0}
+ * @category String
+ * @sig String -> String
+ * @param {string} chars The characters to trim
+ * @param {string} value The string to trim
+ * @return {string} Returns the trimmed string.
+ * @example
+ *
+ * RA.trimCharsEnd('_-', '-_-abc-_-'); //=> '-_-abc'
+ */
+
+var trimCharsEnd = curry(function (chars, value) {
+  return pipe(split(''), dropLastWhile(contained(chars)), join(''))(value);
+});
+export default trimCharsEnd;

package/es/trimCharsStart.js

@@ -0,0 +1,22 @@
+import { curry, dropWhile, join, pipe, split } from 'ramda';
+import contained from './contained';
+/**
+ * Removes specified characters from the beginning of a string.
+ *
+ * @func trimCharsStart
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.24.0|v2.24.0}
+ * @category String
+ * @sig String -> String
+ * @param {string} chars The characters to trim
+ * @param {string} value The string to trim
+ * @return {string} Returns the trimmed string.
+ * @example
+ *
+ * RA.trimCharsStart('_-', '-_-abc-_-'); //=> 'abc-_-'
+ */
+
+var trimCharsStart = curry(function (chars, value) {
+  return pipe(split(''), dropWhile(contained(chars)), join(''))(value);
+});
+export default trimCharsStart;

package/es/trimEnd.js

@@ -0,0 +1,23 @@
+import { invoker } from 'ramda';
+import ponyfill from './internal/ponyfills/String.trimEnd';
+import isFunction from './isFunction';
+export var trimEndPonyfill = ponyfill;
+export var trimEndInvoker = invoker(0, 'trimEnd');
+/**
+ * Removes whitespace from the end of a string.
+ *
+ * @func trimEnd
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category String
+ * @sig String -> String
+ * @param {string} value String value to have the whitespace removed from the end
+ * @return {string} A new string representing the calling string stripped of whitespace from its end (right end).
+ * @see {@link RA.trimEnd|trimEnd}
+ * @example
+ *
+ * RA.trimEnd('abc   '); //=> 'abc'
+ */
+
+var trimEnd = isFunction(String.prototype.trimEnd) ? trimEndInvoker : trimEndPonyfill;
+export default trimEnd;

package/es/trimStart.js

@@ -0,0 +1,22 @@
+import { invoker } from 'ramda';
+import ponyfill from './internal/ponyfills/String.trimStart';
+import isFunction from './isFunction';
+export var trimStartPonyfill = ponyfill;
+export var trimStartInvoker = invoker(0, 'trimStart');
+/**
+ * Removes whitespace from the beginning of a string.
+ *
+ * @func trimStart
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @category String
+ * @sig String -> String
+ * @param {string} value String value to have the whitespace removed from the beginning
+ * @return {string} A new string representing the calling string stripped of whitespace from its beginning (left end).
+ * @example
+ *
+ * RA.trimStart('  abc'); //=> 'abc'
+ */
+
+var trimStart = isFunction(String.prototype.trimStart) ? trimStartInvoker : trimStartPonyfill;
+export default trimStart;

package/es/trunc.js

@@ -0,0 +1,27 @@
+import { bind, curryN } from 'ramda';
+import ponyfill from './internal/ponyfills/Math.trunc';
+import isFunction from './isFunction';
+export var truncPonyfill = curryN(1, ponyfill);
+/**
+ * Returns the integer part of a number by removing any fractional digits.
+ *
+ * @func trunc
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.15.0|v2.15.0}
+ * @category Math
+ * @sig Number | String -> Number
+ * @param {number|string} number The number to trunc
+ * @return {number} The integer part of the given number
+ * @example
+ *
+ * RA.trunc(13.37); //=> 13
+ * RA.trunc(42.84); //=> 42
+ * RA.trunc(0.123); //=>  0
+ * RA.trunc(-0.123); //=> -0
+ * RA.trunc('-1.123'); //=> -1
+ * RA.trunc(NaN); //=> NaN
+ * RA.trunc('foo'); //=> NaN
+ */
+
+var trunc = isFunction(Math.trunc) ? curryN(1, bind(Math.trunc, Math)) : truncPonyfill;
+export default trunc;

package/es/unzipObjWith.js

@@ -0,0 +1,26 @@
+import { apply, curryN, flip, map, pipe, toPairs, transpose, when } from 'ramda';
+import lengthEq from './lengthEq';
+/**
+ * Creates a new list out of the supplied object by applying the function to each key/value pairing.
+ *
+ * @func unzipObjWith
+ * @memberOf RA
+ * @category Object
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @sig  (v, k) => [k, v] -> { k: v } -> [[k], [v]]
+ * @param {Function} fn The function to transform each value-key pair
+ * @param {Object} obj Object to unzip
+ * @return {Array} A pair of tw lists: a list of keys and a list of values
+ * @see {@link https://ramdajs.com/docs/#zipObj|zipObj}, {@link RA.zipObjWith|zipObjWith}
+ * @example
+ *
+ * RA.unzipObjWith((v, k) => [`new${k.toUpperCase()}`, 2 * v], { a: 1, b: 2, c: 3 });
+ * //=> [['newA', 'newB', 'newC'], [2, 4, 6]]
+ */
+
+var unzipObjWith = curryN(2, function (fn, obj) {
+  return pipe(toPairs, map(pipe(flip, apply)(fn)), transpose, when(lengthEq(0), function () {
+    return [[], []];
+  }))(obj);
+});
+export default unzipObjWith;

package/es/viewOr.js

@@ -0,0 +1,30 @@
+import { view, defaultTo, curryN } from 'ramda';
+/**
+ * Returns a "view" of the given data structure, determined by the given lens.
+ * The lens's focus determines which portion of the data structure is visible.
+ * Returns the defaultValue if "view" is null, undefined or NaN; otherwise the "view" is returned.
+ *
+ * @func viewOr
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.13.0|1.13.0}
+ * @category Object
+ * @typedef Lens s b = Functor f => (b -> f b) -> s -> f s
+ * @sig a -> Lens s b -> s -> b | a
+ * @see {@link http://ramdajs.com/docs/#view|R.view}
+ * @param {*} defaultValue The default value
+ * @param {Function} lens Van Laarhoven lens
+ * @param {*} data The data structure
+ * @returns {*} "view" or defaultValue
+ *
+ * @example
+ *
+ * RA.viewOr('N/A', R.lensProp('x'), {}); // => 'N/A'
+ * RA.viewOr('N/A', R.lensProp('x'), { x: 1 }); // => 1
+ * RA.viewOr('some', R.lensProp('y'), { y: null }); // => 'some'
+ * RA.viewOr('some', R.lensProp('y'), { y: false }); // => false
+ */
+
+var viewOr = curryN(3, function (defaultValue, lens, data) {
+  return defaultTo(defaultValue, view(lens, data));
+});
+export default viewOr;

package/es/weave.js

@@ -0,0 +1,36 @@
+import { curryN } from 'ramda';
+/**
+ * Weaves a configuration into function returning the runnable monad like `Reader` or `Free`.
+ * This allows us to pre-bind the configuration in advance and use the weaved function
+ * without need to explicitly pass the configuration on every call.
+ *
+ * @func weave
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.7.0|v1.7.0}
+ * @category Function
+ * @sig (*... -> *) -> * -> (*... -> *)
+ * @param {Function} fn The function to weave
+ * @param {*} config The configuration to weave into fn
+ * @return {Function} Auto-curried weaved function
+ * @example
+ *
+ * const { Reader: reader } = require('monet');
+ *
+ * const log = value => reader(
+ *   config => config.log(value)
+ * );
+ *
+ * // no weaving
+ * log('test').run(console); //=> prints 'test'
+ *
+ * // weaving
+ * const wlog = RA.weave(log, console);
+ * wlog('test'); //=> prints 'test'
+ */
+
+var weave = curryN(2, function (fn, config) {
+  return curryN(fn.length, function () {
+    return fn.apply(void 0, arguments).run(config);
+  });
+});
+export default weave;

package/es/weaveLazy.js

@@ -0,0 +1,38 @@
+import { curryN } from 'ramda';
+/**
+ * Weaves a configuration into function returning the runnable monad like `Reader` or `Free`.
+ * This allows us to pre-bind the configuration in advance and use the weaved function
+ * without need to explicitly pass the configuration on every call.
+ *
+ * @func weaveLazy
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/1.10.0|v1.10.0}
+ * @category Function
+ * @sig (*... -> *) -> (* -> *) -> (*... -> *)
+ * @param {Function} fn The function to weave
+ * @param {Function} configAccessor The function that returns the configuration object
+ * @return {Function} Auto-curried weaved function
+ * @example
+ *
+ * const { Reader: reader } = require('monet');
+ *
+ * const log = value => reader(
+ *   config => config.log(value)
+ * );
+ *
+ * const consoleAccessor = R.always(console);
+ *
+ * // no weaving
+ * log('test').run(console); //=> prints 'test'
+ *
+ * // weaving
+ * const wlog = RA.weaveLazy(log, consoleAccessor);
+ * wlog('test'); //=> prints 'test'
+ */
+
+var weaveLazy = curryN(2, function (fn, configAccessor) {
+  return curryN(fn.length, function () {
+    return fn.apply(void 0, arguments).run(configAccessor());
+  });
+});
+export default weaveLazy;

package/es/zipObjWith.js

@@ -0,0 +1,26 @@
+import { apply, curryN, fromPairs, map, pipe, zip } from 'ramda';
+/**
+ * Creates a new object out of a list of keys and a list of values by applying the function
+ * to each equally-positioned pair in the lists.
+ * Key/value pairing is truncated to the length of the shorter of the two lists.
+ *
+ * @func zipObjWith
+ * @memberOf RA
+ * @category Object
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.22.0|v2.22.0}
+ * @sig (b, a) -> [k, v] -> [a] -> [b] -> { k: v }
+ * @param {Function} fn The function to transform each value-key pair
+ * @param {Array} keys Array to transform into the properties on the output object
+ * @param {Array} values Array to transform into the values on the output object
+ * @return {Object}  The object made by pairing up and transforming same-indexed elements of `keys` and `values`.
+ * @see {@link https://ramdajs.com/docs/#zipObj|zipObj}, {@link RA.unzipObjWith|unzipObjWith}
+ * @example
+ *
+ * RA.zipObjWith((value, key) => [key, `${key}${value + 1}`]), ['a', 'b', 'c'], [1, 2, 3]);
+ *  // => { a: 'a2', b: 'b3', c: 'c4' }
+ */
+
+var zipObjWith = curryN(3, function (fn, keys, values) {
+  return pipe(zip, map(apply(fn)), fromPairs)(values, keys);
+});
+export default zipObjWith;

package/lib/Y.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports["default"] = void 0;
+
+var _ramda = require("ramda");
+
+/**
+ * Y-combinator
+ *
+ * The Y combinator is an interesting function which only works with functional languages,
+ * showing how recursion can still be done even without any variable or function declarations,
+ * only functions and parameters
+ *
+ * @func Y
+ * @memberOf RA
+ * @since {@link https://char0n.github.io/ramda-adjunct/2.3.0|v2.3.0}
+ * @category Function
+ * @sig (a, ... -> b -> b) -> (a, ... -> b)
+ * @param {Function} le Recursive function maker
+ * @return {Function}
+ * @see {@link http://kestas.kuliukas.com/YCombinatorExplained/|Y combinator explained}
+ * @example
+ *
+ * const makeFact = givenFact => (n) => {
+ *   if (n < 2) { return 1 }
+ *   return n * givenFact(n - 1);
+ * };
+ *
+ * const factorial = RA.Y(makeFact);
+ *
+ * factorial(5); //=> 120
+ */
+var Y = (0, _ramda.curryN)(1, function (le) {
+  return function (f) {
+    return f(f);
+  }(function (g) {
+    return le(function (x) {
+      return g(g)(x);
+    });
+  });
+});
+var _default = Y;
+exports["default"] = _default;