Commit 6cc198bf authored by Sangjune Bae's avatar Sangjune Bae
Browse files

first commit

parent 81c6da4b
export default function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
\ No newline at end of file
export default function _skipFirstGeneratorNext(fn) {
return function () {
var it = fn.apply(this, arguments);
it.next();
return it;
};
}
\ No newline at end of file
import arrayWithHoles from "@babel/runtime/helpers/esm/arrayWithHoles";
import iterableToArrayLimit from "@babel/runtime/helpers/esm/iterableToArrayLimit";
import unsupportedIterableToArray from "@babel/runtime/helpers/esm/unsupportedIterableToArray";
import nonIterableRest from "@babel/runtime/helpers/esm/nonIterableRest";
export default function _slicedToArray(arr, i) {
return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
}
\ No newline at end of file
import arrayWithHoles from "@babel/runtime/helpers/esm/arrayWithHoles";
import iterableToArrayLimitLoose from "@babel/runtime/helpers/esm/iterableToArrayLimitLoose";
import unsupportedIterableToArray from "@babel/runtime/helpers/esm/unsupportedIterableToArray";
import nonIterableRest from "@babel/runtime/helpers/esm/nonIterableRest";
export default function _slicedToArrayLoose(arr, i) {
return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();
}
\ No newline at end of file
import getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
export default function _superPropBase(object, property) {
while (!Object.prototype.hasOwnProperty.call(object, property)) {
object = getPrototypeOf(object);
if (object === null) break;
}
return object;
}
\ No newline at end of file
export default function _taggedTemplateLiteral(strings, raw) {
if (!raw) {
raw = strings.slice(0);
}
return Object.freeze(Object.defineProperties(strings, {
raw: {
value: Object.freeze(raw)
}
}));
}
\ No newline at end of file
export default function _taggedTemplateLiteralLoose(strings, raw) {
if (!raw) {
raw = strings.slice(0);
}
strings.raw = raw;
return strings;
}
\ No newline at end of file
export default function _tdzError(name) {
throw new ReferenceError(name + " is not defined - temporal dead zone");
}
\ No newline at end of file
import undef from "@babel/runtime/helpers/esm/temporalUndefined";
import err from "@babel/runtime/helpers/esm/tdz";
export default function _temporalRef(val, name) {
return val === undef ? err(name) : val;
}
\ No newline at end of file
export default function _temporalUndefined() {}
\ No newline at end of file
import arrayWithHoles from "@babel/runtime/helpers/esm/arrayWithHoles";
import iterableToArray from "@babel/runtime/helpers/esm/iterableToArray";
import unsupportedIterableToArray from "@babel/runtime/helpers/esm/unsupportedIterableToArray";
import nonIterableRest from "@babel/runtime/helpers/esm/nonIterableRest";
export default function _toArray(arr) {
return arrayWithHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableRest();
}
\ No newline at end of file
import arrayWithoutHoles from "@babel/runtime/helpers/esm/arrayWithoutHoles";
import iterableToArray from "@babel/runtime/helpers/esm/iterableToArray";
import unsupportedIterableToArray from "@babel/runtime/helpers/esm/unsupportedIterableToArray";
import nonIterableSpread from "@babel/runtime/helpers/esm/nonIterableSpread";
export default function _toConsumableArray(arr) {
return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();
}
\ No newline at end of file
import _typeof from "@babel/runtime/helpers/esm/typeof";
export default function _toPrimitive(input, hint) {
if (_typeof(input) !== "object" || input === null) return input;
var prim = input[Symbol.toPrimitive];
if (prim !== undefined) {
var res = prim.call(input, hint || "default");
if (_typeof(res) !== "object") return res;
throw new TypeError("@@toPrimitive must return a primitive value.");
}
return (hint === "string" ? String : Number)(input);
}
\ No newline at end of file
import _typeof from "@babel/runtime/helpers/esm/typeof";
import toPrimitive from "@babel/runtime/helpers/esm/toPrimitive";
export default function _toPropertyKey(arg) {
var key = toPrimitive(arg, "string");
return _typeof(key) === "symbol" ? key : String(key);
}
\ No newline at end of file
export default function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function _typeof(obj) {
return typeof obj;
};
} else {
_typeof = function _typeof(obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
}
return _typeof(obj);
}
\ No newline at end of file
import arrayLikeToArray from "@babel/runtime/helpers/esm/arrayLikeToArray";
export default function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(o);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);
}
\ No newline at end of file
import AsyncGenerator from "@babel/runtime/helpers/esm/AsyncGenerator";
export default function _wrapAsyncGenerator(fn) {
return function () {
return new AsyncGenerator(fn.apply(this, arguments));
};
}
\ No newline at end of file
import getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
import setPrototypeOf from "@babel/runtime/helpers/esm/setPrototypeOf";
import isNativeFunction from "@babel/runtime/helpers/esm/isNativeFunction";
import construct from "@babel/runtime/helpers/esm/construct";
export default function _wrapNativeSuper(Class) {
var _cache = typeof Map === "function" ? new Map() : undefined;
_wrapNativeSuper = function _wrapNativeSuper(Class) {
if (Class === null || !isNativeFunction(Class)) return Class;
if (typeof Class !== "function") {
throw new TypeError("Super expression must either be null or a function");
}
if (typeof _cache !== "undefined") {
if (_cache.has(Class)) return _cache.get(Class);
_cache.set(Class, Wrapper);
}
function Wrapper() {
return construct(Class, arguments, getPrototypeOf(this).constructor);
}
Wrapper.prototype = Object.create(Class.prototype, {
constructor: {
value: Wrapper,
enumerable: false,
writable: true,
configurable: true
}
});
return setPrototypeOf(Wrapper, Class);
};
return _wrapNativeSuper(Class);
}
\ No newline at end of file
import _typeof from "@babel/runtime/helpers/esm/typeof";
import wrapNativeSuper from "@babel/runtime/helpers/esm/wrapNativeSuper";
import getPrototypeOf from "@babel/runtime/helpers/esm/getPrototypeOf";
import possibleConstructorReturn from "@babel/runtime/helpers/esm/possibleConstructorReturn";
import inherits from "@babel/runtime/helpers/esm/inherits";
export default function _wrapRegExp(re, groups) {
_wrapRegExp = function _wrapRegExp(re, groups) {
return new BabelRegExp(re, undefined, groups);
};
var _RegExp = wrapNativeSuper(RegExp);
var _super = RegExp.prototype;
var _groups = new WeakMap();
function BabelRegExp(re, flags, groups) {
var _this = _RegExp.call(this, re, flags);
_groups.set(_this, groups || _groups.get(re));
return _this;
}
inherits(BabelRegExp, _RegExp);
BabelRegExp.prototype.exec = function (str) {
var result = _super.exec.call(this, str);
if (result) result.groups = buildGroups(result, this);
return result;
};
BabelRegExp.prototype[Symbol.replace] = function (str, substitution) {
if (typeof substitution === "string") {
var groups = _groups.get(this);
return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) {
return "$" + groups[name];
}));
} else if (typeof substitution === "function") {
var _this = this;
return _super[Symbol.replace].call(this, str, function () {
var args = [];
args.push.apply(args, arguments);
if (_typeof(args[args.length - 1]) !== "object") {
args.push(buildGroups(args, _this));
}
return substitution.apply(this, args);
});
} else {
return _super[Symbol.replace].call(this, str, substitution);
}
};
function buildGroups(result, re) {
var g = _groups.get(re);
return Object.keys(g).reduce(function (groups, name) {
groups[name] = result[g[name]];
return groups;
}, Object.create(null));
}
return _wrapRegExp.apply(this, arguments);
}
\ No newline at end of file
function _extends() {
module.exports = _extends = Object.assign || function (target) {
for (var i = 1; i < arguments.length; i++) {
var source = arguments[i];
for (var key in source) {
if (Object.prototype.hasOwnProperty.call(source, key)) {
target[key] = source[key];
}
}
}
return target;
};
return _extends.apply(this, arguments);
}
module.exports = _extends;
\ No newline at end of file
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment