s2/minifyfromhtml
1
0
Fork 0
mirror of https://github.com/S2-/minifyfromhtml.git synced 2025-08-03 12:20:04 +02:00
Code Issues Releases Wiki Activity

add some babel stuff

Browse Source
This commit is contained in:
s2
2018-05-05 15:35:25 +02:00
parent d17c4fe70c
commit e76e795120
604 changed files with 103725 additions and 62 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
node_modules/@babel/helpers/README.md generated vendored Normal file
View File

@@ -0,0 +1,56 @@
# @babel/helpers
> Collection of helper functions used by Babel transforms.
## Install
```sh
npm install --save-dev @babel/helpers
```
## Usage
Direct:
```js
import * as helpers from '@babel/helpers';
import * as t from '@babel/types';
const typeofHelper = helpers.get('typeof');
t.isExpressionStatement(typeofHelper);
// true
```
Inside a plugin:
```js
export default {
visitor: {
UnaryExpression(path) {
// The .addHelper function adds, if needed, the helper to the file
// and returns an expression which references the helper
const typeofHelper = this.addHelper("typeof");
t.isExpression(typeofHelper); // true
}
};
```
## Defining Helpers
> **NOTE**: This package is only meant to be used by the packages inluded in this repository. There is currently no way for third-party plugins to define an helper.
Helpers are defined in the `src/helpers.js` file, and they must be valid modules which follow these guidelines:
- They must have a default export, which is their entry-point.
- They can import other helpers, exclusively by using default imports.
- They can't have named exports.
```js
helpers.customHelper = defineHelper(`
import dep from "dependency";
const foo = 2;
export default function getFooTimesDepPlusX(x) {
return foo * dep() + x;
}
`);
```

300
node_modules/@babel/helpers/lib/helpers.js generated vendored Normal file
View File

@@ -0,0 +1,300 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
function _template() {
var data = _interopRequireDefault(require("@babel/template"));
_template = function _template() {
return data;
};
return data;
}
var _templateObject = _taggedTemplateLiteralLoose(["\n export default function _typeof(obj) {\n if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n _typeof = function (obj) { return typeof obj; };\n } else {\n _typeof = function (obj) {\n return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype\n ? \"symbol\"\n : typeof obj;\n };\n }\n\n return _typeof(obj);\n }\n"]),
_templateObject2 = _taggedTemplateLiteralLoose(["\n var REACT_ELEMENT_TYPE;\n\n export default function _createRawReactElement(type, props, key, children) {\n if (!REACT_ELEMENT_TYPE) {\n REACT_ELEMENT_TYPE = (\n typeof Symbol === \"function\" && Symbol.for && Symbol.for(\"react.element\")\n ) || 0xeac7;\n }\n\n var defaultProps = type && type.defaultProps;\n var childrenLength = arguments.length - 3;\n\n if (!props && childrenLength !== 0) {\n // If we're going to assign props.children, we create a new object now\n // to avoid mutating defaultProps.\n props = {\n children: void 0,\n };\n }\n if (props && defaultProps) {\n for (var propName in defaultProps) {\n if (props[propName] === void 0) {\n props[propName] = defaultProps[propName];\n }\n }\n } else if (!props) {\n props = defaultProps || {};\n }\n\n if (childrenLength === 1) {\n props.children = children;\n } else if (childrenLength > 1) {\n var childArray = new Array(childrenLength);\n for (var i = 0; i < childrenLength; i++) {\n childArray[i] = arguments[i + 3];\n }\n props.children = childArray;\n }\n\n return {\n $$typeof: REACT_ELEMENT_TYPE,\n type: type,\n key: key === undefined ? null : '' + key,\n ref: null,\n props: props,\n _owner: null,\n };\n }\n"]),
_templateObject3 = _taggedTemplateLiteralLoose(["\n export default function _asyncIterator(iterable) {\n var method\n if (typeof Symbol === \"function\") {\n if (Symbol.asyncIterator) {\n method = iterable[Symbol.asyncIterator]\n if (method != null) return method.call(iterable);\n }\n if (Symbol.iterator) {\n method = iterable[Symbol.iterator]\n if (method != null) return method.call(iterable);\n }\n }\n throw new TypeError(\"Object is not async iterable\");\n }\n"]),
_templateObject4 = _taggedTemplateLiteralLoose(["\n export default function _AwaitValue(value) {\n this.wrapped = value;\n }\n"]),
_templateObject5 = _taggedTemplateLiteralLoose(["\n import AwaitValue from \"AwaitValue\";\n\n export default function AsyncGenerator(gen) {\n var front, back;\n\n function send(key, arg) {\n return new Promise(function (resolve, reject) {\n var request = {\n key: key,\n arg: arg,\n resolve: resolve,\n reject: reject,\n next: null,\n };\n\n if (back) {\n back = back.next = request;\n } else {\n front = back = request;\n resume(key, arg);\n }\n });\n }\n\n function resume(key, arg) {\n try {\n var result = gen[key](arg)\n var value = result.value;\n var wrappedAwait = value instanceof AwaitValue;\n\n Promise.resolve(wrappedAwait ? value.wrapped : value).then(\n function (arg) {\n if (wrappedAwait) {\n resume(\"next\", arg);\n return\n }\n\n settle(result.done ? \"return\" : \"normal\", arg);\n },\n function (err) { resume(\"throw\", err); });\n } catch (err) {\n settle(\"throw\", err);\n }\n }\n\n function settle(type, value) {\n switch (type) {\n case \"return\":\n front.resolve({ value: value, done: true });\n break;\n case \"throw\":\n front.reject(value);\n break;\n default:\n front.resolve({ value: value, done: false });\n break;\n }\n\n front = front.next;\n if (front) {\n resume(front.key, front.arg);\n } else {\n back = null;\n }\n }\n\n this._invoke = send;\n\n // Hide \"return\" method if generator return is not supported\n if (typeof gen.return !== \"function\") {\n this.return = undefined;\n }\n }\n\n if (typeof Symbol === \"function\" && Symbol.asyncIterator) {\n AsyncGenerator.prototype[Symbol.asyncIterator] = function () { return this; };\n }\n\n AsyncGenerator.prototype.next = function (arg) { return this._invoke(\"next\", arg); };\n AsyncGenerator.prototype.throw = function (arg) { return this._invoke(\"throw\", arg); };\n AsyncGenerator.prototype.return = function (arg) { return this._invoke(\"return\", arg); };\n"]),
_templateObject6 = _taggedTemplateLiteralLoose(["\n import AsyncGenerator from \"AsyncGenerator\";\n\n export default function _wrapAsyncGenerator(fn) {\n return function () {\n return new AsyncGenerator(fn.apply(this, arguments));\n };\n }\n"]),
_templateObject7 = _taggedTemplateLiteralLoose(["\n import AwaitValue from \"AwaitValue\";\n\n export default function _awaitAsyncGenerator(value) {\n return new AwaitValue(value);\n }\n"]),
_templateObject8 = _taggedTemplateLiteralLoose(["\n export default function _asyncGeneratorDelegate(inner, awaitWrap) {\n var iter = {}, waiting = false;\n\n function pump(key, value) {\n waiting = true;\n value = new Promise(function (resolve) { resolve(inner[key](value)); });\n return { done: false, value: awaitWrap(value) };\n };\n\n if (typeof Symbol === \"function\" && Symbol.iterator) {\n iter[Symbol.iterator] = function () { return this; };\n }\n\n iter.next = function (value) {\n if (waiting) {\n waiting = false;\n return value;\n }\n return pump(\"next\", value);\n };\n\n if (typeof inner.throw === \"function\") {\n iter.throw = function (value) {\n if (waiting) {\n waiting = false;\n throw value;\n }\n return pump(\"throw\", value);\n };\n }\n\n if (typeof inner.return === \"function\") {\n iter.return = function (value) {\n return pump(\"return\", value);\n };\n }\n\n return iter;\n }\n"]),
_templateObject9 = _taggedTemplateLiteralLoose(["\n export default function _asyncToGenerator(fn) {\n return function () {\n var self = this, args = arguments;\n return new Promise(function (resolve, reject) {\n var gen = fn.apply(self, args);\n function step(key, arg) {\n try {\n var info = gen[key](arg);\n var value = info.value;\n } catch (error) {\n reject(error);\n return;\n }\n\n if (info.done) {\n resolve(value);\n } else {\n Promise.resolve(value).then(_next, _throw);\n }\n }\n function _next(value) { step(\"next\", value); }\n function _throw(err) { step(\"throw\", err); }\n\n _next();\n });\n };\n }\n"]),
_templateObject10 = _taggedTemplateLiteralLoose(["\n export default function _classCallCheck(instance, Constructor) {\n if (!(instance instanceof Constructor)) {\n throw new TypeError(\"Cannot call a class as a function\");\n }\n }\n"]),
_templateObject11 = _taggedTemplateLiteralLoose(["\n function _defineProperties(target, props) {\n for (var i = 0; i < props.length; i ++) {\n var descriptor = props[i];\n descriptor.enumerable = descriptor.enumerable || false;\n descriptor.configurable = true;\n if (\"value\" in descriptor) descriptor.writable = true;\n Object.defineProperty(target, descriptor.key, descriptor);\n }\n }\n\n export default function _createClass(Constructor, protoProps, staticProps) {\n if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n if (staticProps) _defineProperties(Constructor, staticProps);\n return Constructor;\n }\n"]),
_templateObject12 = _taggedTemplateLiteralLoose(["\n export default function _defineEnumerableProperties(obj, descs) {\n for (var key in descs) {\n var desc = descs[key];\n desc.configurable = desc.enumerable = true;\n if (\"value\" in desc) desc.writable = true;\n Object.defineProperty(obj, key, desc);\n }\n\n // Symbols are not enumerated over by for-in loops. If native\n // Symbols are available, fetch all of the descs object's own\n // symbol properties and define them on our target object too.\n if (Object.getOwnPropertySymbols) {\n var objectSymbols = Object.getOwnPropertySymbols(descs);\n for (var i = 0; i < objectSymbols.length; i++) {\n var sym = objectSymbols[i];\n var desc = descs[sym];\n desc.configurable = desc.enumerable = true;\n if (\"value\" in desc) desc.writable = true;\n Object.defineProperty(obj, sym, desc);\n }\n }\n return obj;\n }\n"]),
_templateObject13 = _taggedTemplateLiteralLoose(["\n export default function _defaults(obj, defaults) {\n var keys = Object.getOwnPropertyNames(defaults);\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n var value = Object.getOwnPropertyDescriptor(defaults, key);\n if (value && value.configurable && obj[key] === undefined) {\n Object.defineProperty(obj, key, value);\n }\n }\n return obj;\n }\n"]),
_templateObject14 = _taggedTemplateLiteralLoose(["\n export default function _defineProperty(obj, key, value) {\n // Shortcircuit the slow defineProperty path when possible.\n // We are trying to avoid issues where setters defined on the\n // prototype cause side effects under the fast path of simple\n // assignment. By checking for existence of the property with\n // the in operator, we can optimize most of this overhead away.\n if (key in obj) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true\n });\n } else {\n obj[key] = value;\n }\n return obj;\n }\n"]),
_templateObject15 = _taggedTemplateLiteralLoose(["\n export default function _extends() {\n _extends = Object.assign || function (target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i];\n for (var key in source) {\n if (Object.prototype.hasOwnProperty.call(source, key)) {\n target[key] = source[key];\n }\n }\n }\n return target;\n };\n\n return _extends.apply(this, arguments);\n }\n"]),
_templateObject16 = _taggedTemplateLiteralLoose(["\n import defineProperty from \"defineProperty\";\n\n export default function _objectSpread(target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = (arguments[i] != null) ? arguments[i] : {};\n var ownKeys = Object.keys(source);\n if (typeof Object.getOwnPropertySymbols === 'function') {\n ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {\n return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n }));\n }\n ownKeys.forEach(function(key) {\n defineProperty(target, key, source[key]);\n });\n }\n return target;\n }\n"]),
_templateObject17 = _taggedTemplateLiteralLoose(["\n import setPrototypeOf from \"setPrototypeOf\";\n\n export default function _inherits(subClass, superClass) {\n if (typeof superClass !== \"function\" && superClass !== null) {\n throw new TypeError(\"Super expression must either be null or a function\");\n }\n setPrototypeOf(subClass.prototype, superClass && superClass.prototype);\n if (superClass) setPrototypeOf(subClass, superClass);\n }\n"]),
_templateObject18 = _taggedTemplateLiteralLoose(["\n export default function _inheritsLoose(subClass, superClass) {\n subClass.prototype.__proto__ = superClass && superClass.prototype;\n subClass.__proto__ = superClass;\n }\n"]),
_templateObject19 = _taggedTemplateLiteralLoose(["\n export default function _getPrototypeOf(o) {\n _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) {\n return o.__proto__;\n };\n return _getPrototypeOf(o);\n }\n"]),
_templateObject20 = _taggedTemplateLiteralLoose(["\n export default function _setPrototypeOf(o, p) {\n _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n o.__proto__ = p;\n return o;\n };\n return _setPrototypeOf(o, p);\n }\n"]),
_templateObject21 = _taggedTemplateLiteralLoose(["\n import setPrototypeOf from \"setPrototypeOf\";\n\n export default function _construct(Parent, args, Class) {\n if (typeof Reflect !== \"undefined\" && Reflect.construct) {\n _construct = Reflect.construct;\n } else {\n _construct = function _construct(Parent, args, Class) {\n var a = [null];\n a.push.apply(a, args);\n var Constructor = Parent.bind.apply(Parent, a);\n var instance = new Constructor();\n if (Class) setPrototypeOf(instance, Class.prototype);\n return instance;\n };\n }\n // Avoid issues with Class being present but undefined when it wasn't\n // present in the original call.\n return _construct.apply(null, arguments);\n }\n"]),
_templateObject22 = _taggedTemplateLiteralLoose(["\n import _gPO from \"getPrototypeOf\";\n import _sPO from \"setPrototypeOf\";\n import construct from \"construct\";\n\n export default function _wrapNativeSuper(Class) {\n var _cache = typeof Map === \"function\" ? new Map() : undefined;\n\n _wrapNativeSuper = function _wrapNativeSuper(Class) {\n if (typeof Class !== \"function\") {\n throw new TypeError(\"Super expression must either be null or a function\");\n }\n if (typeof _cache !== \"undefined\") {\n if (_cache.has(Class)) return _cache.get(Class);\n _cache.set(Class, Wrapper);\n }\n function Wrapper() {}\n Wrapper.prototype = Object.create(Class.prototype, {\n constructor: {\n value: Wrapper,\n enumerable: false,\n writable: true,\n configurable: true,\n }\n });\n return _sPO(\n Wrapper,\n _sPO(\n function Super() {\n return construct(Class, arguments, _gPO(this).constructor);\n },\n Class\n )\n );\n }\n\n return _wrapNativeSuper(Class)\n }\n"]),
_templateObject23 = _taggedTemplateLiteralLoose(["\n export default function _instanceof(left, right) {\n if (right != null && typeof Symbol !== \"undefined\" && right[Symbol.hasInstance]) {\n return right[Symbol.hasInstance](left);\n } else {\n return left instanceof right;\n }\n }\n"]),
_templateObject24 = _taggedTemplateLiteralLoose(["\n export default function _interopRequireDefault(obj) {\n return obj && obj.__esModule ? obj : { default: obj };\n }\n"]),
_templateObject25 = _taggedTemplateLiteralLoose(["\n export default function _interopRequireWildcard(obj) {\n if (obj && obj.__esModule) {\n return obj;\n } else {\n var newObj = {};\n if (obj != null) {\n for (var key in obj) {\n if (Object.prototype.hasOwnProperty.call(obj, key)) {\n var desc = Object.defineProperty && Object.getOwnPropertyDescriptor\n ? Object.getOwnPropertyDescriptor(obj, key)\n : {};\n if (desc.get || desc.set) {\n Object.defineProperty(newObj, key, desc);\n } else {\n newObj[key] = obj[key];\n }\n }\n }\n }\n newObj.default = obj;\n return newObj;\n }\n }\n"]),
_templateObject26 = _taggedTemplateLiteralLoose(["\n export default function _newArrowCheck(innerThis, boundThis) {\n if (innerThis !== boundThis) {\n throw new TypeError(\"Cannot instantiate an arrow function\");\n }\n }\n"]),
_templateObject27 = _taggedTemplateLiteralLoose(["\n export default function _objectDestructuringEmpty(obj) {\n if (obj == null) throw new TypeError(\"Cannot destructure undefined\");\n }\n"]),
_templateObject28 = _taggedTemplateLiteralLoose(["\n export default function _objectWithoutProperties(source, excluded) {\n if (source == null) return {};\n\n var target = {};\n var sourceKeys = Object.keys(source);\n var key, i;\n\n for (i = 0; i < sourceKeys.length; i++) {\n key = sourceKeys[i];\n if (excluded.indexOf(key) >= 0) continue;\n target[key] = source[key];\n }\n\n if (Object.getOwnPropertySymbols) {\n var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n for (i = 0; i < sourceSymbolKeys.length; i++) {\n key = sourceSymbolKeys[i];\n if (excluded.indexOf(key) >= 0) continue;\n if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n target[key] = source[key];\n }\n }\n\n return target;\n }\n"]),
_templateObject29 = _taggedTemplateLiteralLoose(["\n export default function _assertThisInitialized(self) {\n if (self === void 0) {\n throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n }\n return self;\n }\n"]),
_templateObject30 = _taggedTemplateLiteralLoose(["\n import assertThisInitialized from \"assertThisInitialized\";\n\n export default function _possibleConstructorReturn(self, call) {\n if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n return call;\n }\n return assertThisInitialized(self);\n }\n"]),
_templateObject31 = _taggedTemplateLiteralLoose(["\n import getPrototypeOf from \"getPrototypeOf\";\n\n export default function _superPropBase(object, property) {\n // Yes, this throws if object is null to being with, that's on purpose.\n while (!Object.prototype.hasOwnProperty.call(object, property)) {\n object = getPrototypeOf(object);\n if (object === null) break;\n }\n return object;\n }\n"]),
_templateObject32 = _taggedTemplateLiteralLoose(["\n import getPrototypeOf from \"getPrototypeOf\";\n import superPropBase from \"superPropBase\";\n\n export default function _get(target, property, receiver) {\n if (typeof Reflect !== \"undefined\" && Reflect.get) {\n _get = Reflect.get;\n } else {\n _get = function _get(target, property, receiver) {\n var base = superPropBase(target, property);\n\n if (!base) return;\n\n var desc = Object.getOwnPropertyDescriptor(base, property);\n if (desc.get) {\n return desc.get.call(receiver);\n }\n\n return desc.value;\n };\n }\n return _get(target, property, receiver || target);\n }\n"]),
_templateObject33 = _taggedTemplateLiteralLoose(["\n import getPrototypeOf from \"getPrototypeOf\";\n import superPropBase from \"superPropBase\";\n import defineProperty from \"defineProperty\";\n\n function set(target, property, value, receiver) {\n if (typeof Reflect !== \"undefined\" && Reflect.set) {\n set = Reflect.set;\n } else {\n set = function set(target, property, value, receiver) {\n var base = superPropBase(target, property);\n var desc;\n\n if (base) {\n desc = Object.getOwnPropertyDescriptor(base, property);\n if (desc.set) {\n desc.set.call(receiver, value);\n return true;\n } else if (!desc.writable) {\n // Both getter and non-writable fall into this.\n return false;\n }\n }\n\n // Without a super that defines the property, spec boils down to\n // \"define on receiver\" for some reason.\n desc = Object.getOwnPropertyDescriptor(receiver, property);\n if (desc) {\n if (!desc.writable) {\n // Setter, getter, and non-writable fall into this.\n return false;\n }\n\n desc.value = value;\n Object.defineProperty(receiver, property, desc);\n } else {\n // Avoid setters that may be defined on Sub's prototype, but not on\n // the instance.\n defineProperty(receiver, property, value);\n }\n\n return true;\n };\n }\n\n return set(target, property, value, receiver);\n }\n\n export default function _set(target, property, value, receiver, isStrict) {\n const s = set(target, property, value, receiver || target);\n if (!s && isStrict) {\n throw new Error('failed to set property');\n }\n\n return value;\n }\n"]),
_templateObject34 = _taggedTemplateLiteralLoose(["\n export default function _taggedTemplateLiteral(strings, raw) {\n if (!raw) { raw = strings.slice(0); }\n return Object.freeze(Object.defineProperties(strings, {\n raw: { value: Object.freeze(raw) }\n }));\n }\n"]),
_templateObject35 = _taggedTemplateLiteralLoose(["\n export default function _taggedTemplateLiteralLoose(strings, raw) {\n if (!raw) { raw = strings.slice(0); }\n strings.raw = raw;\n return strings;\n }\n"]),
_templateObject36 = _taggedTemplateLiteralLoose(["\n import undef from \"temporalUndefined\";\n\n export default function _temporalRef(val, name) {\n if (val === undef) {\n throw new ReferenceError(name + \" is not defined - temporal dead zone\");\n } else {\n return val;\n }\n }\n"]),
_templateObject37 = _taggedTemplateLiteralLoose(["\n export default function _readOnlyError(name) {\n throw new Error(\"\\\"\" + name + \"\\\" is read-only\");\n }\n"], ["\n export default function _readOnlyError(name) {\n throw new Error(\"\\\\\"\" + name + \"\\\\\" is read-only\");\n }\n"]),
_templateObject38 = _taggedTemplateLiteralLoose(["\n export default function _classNameTDZError(name) {\n throw new Error(\"Class \\\"\" + name + \"\\\" cannot be referenced in computed property keys.\");\n }\n"], ["\n export default function _classNameTDZError(name) {\n throw new Error(\"Class \\\\\"\" + name + \"\\\\\" cannot be referenced in computed property keys.\");\n }\n"]),
_templateObject39 = _taggedTemplateLiteralLoose(["\n export default {};\n"]),
_templateObject40 = _taggedTemplateLiteralLoose(["\n import arrayWithHoles from \"arrayWithHoles\";\n import iterableToArrayLimit from \"iterableToArrayLimit\";\n import nonIterableRest from \"nonIterableRest\";\n\n export default function _slicedToArray(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();\n }\n"]),
_templateObject41 = _taggedTemplateLiteralLoose(["\n import arrayWithHoles from \"arrayWithHoles\";\n import iterableToArrayLimitLoose from \"iterableToArrayLimitLoose\";\n import nonIterableRest from \"nonIterableRest\";\n\n export default function _slicedToArrayLoose(arr, i) {\n return arrayWithHoles(arr) || iterableToArrayLimitLoose(arr, i) || nonIterableRest();\n }\n"]),
_templateObject42 = _taggedTemplateLiteralLoose(["\n import arrayWithHoles from \"arrayWithHoles\";\n import iterableToArray from \"iterableToArray\";\n import nonIterableRest from \"nonIterableRest\";\n\n export default function _toArray(arr) {\n return arrayWithHoles(arr) || iterableToArray(arr) || nonIterableRest();\n }\n"]),
_templateObject43 = _taggedTemplateLiteralLoose(["\n import arrayWithoutHoles from \"arrayWithoutHoles\";\n import iterableToArray from \"iterableToArray\";\n import nonIterableSpread from \"nonIterableSpread\";\n\n export default function _toConsumableArray(arr) {\n return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();\n }\n"]),
_templateObject44 = _taggedTemplateLiteralLoose(["\n export default function _arrayWithoutHoles(arr) {\n if (Array.isArray(arr)) {\n for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];\n return arr2;\n }\n }\n"]),
_templateObject45 = _taggedTemplateLiteralLoose(["\n export default function _arrayWithHoles(arr) {\n if (Array.isArray(arr)) return arr;\n }\n"]),
_templateObject46 = _taggedTemplateLiteralLoose(["\n export default function _iterableToArray(iter) {\n if (\n Symbol.iterator in Object(iter) ||\n Object.prototype.toString.call(iter) === \"[object Arguments]\"\n ) return Array.from(iter);\n }\n"]),
_templateObject47 = _taggedTemplateLiteralLoose(["\n export default function _iterableToArrayLimit(arr, i) {\n // this is an expanded form of `for...of` that properly supports abrupt completions of\n // iterators etc. variable names have been minimised to reduce the size of this massive\n // helper. sometimes spec compliancy is annoying :(\n //\n // _n = _iteratorNormalCompletion\n // _d = _didIteratorError\n // _e = _iteratorError\n // _i = _iterator\n // _s = _step\n\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n _arr.push(_s.value);\n if (i && _arr.length === i) break;\n }\n } catch (err) {\n _d = true;\n _e = err;\n } finally {\n try {\n if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n } finally {\n if (_d) throw _e;\n }\n }\n return _arr;\n }\n"], ["\n export default function _iterableToArrayLimit(arr, i) {\n // this is an expanded form of \\`for...of\\` that properly supports abrupt completions of\n // iterators etc. variable names have been minimised to reduce the size of this massive\n // helper. sometimes spec compliancy is annoying :(\n //\n // _n = _iteratorNormalCompletion\n // _d = _didIteratorError\n // _e = _iteratorError\n // _i = _iterator\n // _s = _step\n\n var _arr = [];\n var _n = true;\n var _d = false;\n var _e = undefined;\n try {\n for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {\n _arr.push(_s.value);\n if (i && _arr.length === i) break;\n }\n } catch (err) {\n _d = true;\n _e = err;\n } finally {\n try {\n if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n } finally {\n if (_d) throw _e;\n }\n }\n return _arr;\n }\n"]),
_templateObject48 = _taggedTemplateLiteralLoose(["\n export default function _iterableToArrayLimitLoose(arr, i) {\n var _arr = [];\n for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {\n _arr.push(_step.value);\n if (i && _arr.length === i) break;\n }\n return _arr;\n }\n"]),
_templateObject49 = _taggedTemplateLiteralLoose(["\n export default function _nonIterableSpread() {\n throw new TypeError(\"Invalid attempt to spread non-iterable instance\");\n }\n"]),
_templateObject50 = _taggedTemplateLiteralLoose(["\n export default function _nonIterableRest() {\n throw new TypeError(\"Invalid attempt to destructure non-iterable instance\");\n }\n"]),
_templateObject51 = _taggedTemplateLiteralLoose(["\n export default function _skipFirstGeneratorNext(fn) {\n return function () {\n var it = fn.apply(this, arguments);\n it.next();\n return it;\n }\n }\n"]),
_templateObject52 = _taggedTemplateLiteralLoose(["\n export default function _toPropertyKey(key) {\n if (typeof key === \"symbol\") {\n return key;\n } else {\n return String(key);\n }\n }\n"]),
_templateObject53 = _taggedTemplateLiteralLoose(["\n export default function _initializerWarningHelper(descriptor, context){\n throw new Error(\n 'Decorating class property failed. Please ensure that ' +\n 'proposal-class-properties is enabled and set to use loose mode. ' +\n 'To use proposal-class-properties in spec mode with decorators, wait for ' +\n 'the next major version of decorators in stage 2.'\n );\n }\n"]),
_templateObject54 = _taggedTemplateLiteralLoose(["\n export default function _initializerDefineProperty(target, property, descriptor, context){\n if (!descriptor) return;\n\n Object.defineProperty(target, property, {\n enumerable: descriptor.enumerable,\n configurable: descriptor.configurable,\n writable: descriptor.writable,\n value: descriptor.initializer ? descriptor.initializer.call(context) : void 0,\n });\n }\n"]),
_templateObject55 = _taggedTemplateLiteralLoose(["\n export default function _applyDecoratedDescriptor(target, property, decorators, descriptor, context){\n var desc = {};\n Object['ke' + 'ys'](descriptor).forEach(function(key){\n desc[key] = descriptor[key];\n });\n desc.enumerable = !!desc.enumerable;\n desc.configurable = !!desc.configurable;\n if ('value' in desc || desc.initializer){\n desc.writable = true;\n }\n\n desc = decorators.slice().reverse().reduce(function(desc, decorator){\n return decorator(target, property, desc) || desc;\n }, desc);\n\n if (context && desc.initializer !== void 0){\n desc.value = desc.initializer ? desc.initializer.call(context) : void 0;\n desc.initializer = undefined;\n }\n\n if (desc.initializer === void 0){\n // This is a hack to avoid this being processed by 'transform-runtime'.\n // See issue #9.\n Object['define' + 'Property'](target, property, desc);\n desc = null;\n }\n\n return desc;\n }\n"]);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _taggedTemplateLiteralLoose(strings, raw) { if (!raw) { raw = strings.slice(0); } strings.raw = raw; return strings; }
var helpers = {};
var _default = helpers;
exports.default = _default;
helpers.typeof = function () {
return _template().default.program.ast(_templateObject);
};
helpers.jsx = function () {
return _template().default.program.ast(_templateObject2);
};
helpers.asyncIterator = function () {
return _template().default.program.ast(_templateObject3);
};
helpers.AwaitValue = function () {
return _template().default.program.ast(_templateObject4);
};
helpers.AsyncGenerator = function () {
return _template().default.program.ast(_templateObject5);
};
helpers.wrapAsyncGenerator = function () {
return _template().default.program.ast(_templateObject6);
};
helpers.awaitAsyncGenerator = function () {
return _template().default.program.ast(_templateObject7);
};
helpers.asyncGeneratorDelegate = function () {
return _template().default.program.ast(_templateObject8);
};
helpers.asyncToGenerator = function () {
return _template().default.program.ast(_templateObject9);
};
helpers.classCallCheck = function () {
return _template().default.program.ast(_templateObject10);
};
helpers.createClass = function () {
return _template().default.program.ast(_templateObject11);
};
helpers.defineEnumerableProperties = function () {
return _template().default.program.ast(_templateObject12);
};
helpers.defaults = function () {
return _template().default.program.ast(_templateObject13);
};
helpers.defineProperty = function () {
return _template().default.program.ast(_templateObject14);
};
helpers.extends = function () {
return _template().default.program.ast(_templateObject15);
};
helpers.objectSpread = function () {
return _template().default.program.ast(_templateObject16);
};
helpers.inherits = function () {
return _template().default.program.ast(_templateObject17);
};
helpers.inheritsLoose = function () {
return _template().default.program.ast(_templateObject18);
};
helpers.getPrototypeOf = function () {
return _template().default.program.ast(_templateObject19);
};
helpers.setPrototypeOf = function () {
return _template().default.program.ast(_templateObject20);
};
helpers.construct = function () {
return _template().default.program.ast(_templateObject21);
};
helpers.wrapNativeSuper = function () {
return _template().default.program.ast(_templateObject22);
};
helpers.instanceof = function () {
return _template().default.program.ast(_templateObject23);
};
helpers.interopRequireDefault = function () {
return _template().default.program.ast(_templateObject24);
};
helpers.interopRequireWildcard = function () {
return _template().default.program.ast(_templateObject25);
};
helpers.newArrowCheck = function () {
return _template().default.program.ast(_templateObject26);
};
helpers.objectDestructuringEmpty = function () {
return _template().default.program.ast(_templateObject27);
};
helpers.objectWithoutProperties = function () {
return _template().default.program.ast(_templateObject28);
};
helpers.assertThisInitialized = function () {
return _template().default.program.ast(_templateObject29);
};
helpers.possibleConstructorReturn = function () {
return _template().default.program.ast(_templateObject30);
};
helpers.superPropBase = function () {
return _template().default.program.ast(_templateObject31);
};
helpers.get = function () {
return _template().default.program.ast(_templateObject32);
};
helpers.set = function () {
return _template().default.program.ast(_templateObject33);
};
helpers.taggedTemplateLiteral = function () {
return _template().default.program.ast(_templateObject34);
};
helpers.taggedTemplateLiteralLoose = function () {
return _template().default.program.ast(_templateObject35);
};
helpers.temporalRef = function () {
return _template().default.program.ast(_templateObject36);
};
helpers.readOnlyError = function () {
return _template().default.program.ast(_templateObject37);
};
helpers.classNameTDZError = function () {
return _template().default.program.ast(_templateObject38);
};
helpers.temporalUndefined = function () {
return _template().default.program.ast(_templateObject39);
};
helpers.slicedToArray = function () {
return _template().default.program.ast(_templateObject40);
};
helpers.slicedToArrayLoose = function () {
return _template().default.program.ast(_templateObject41);
};
helpers.toArray = function () {
return _template().default.program.ast(_templateObject42);
};
helpers.toConsumableArray = function () {
return _template().default.program.ast(_templateObject43);
};
helpers.arrayWithoutHoles = function () {
return _template().default.program.ast(_templateObject44);
};
helpers.arrayWithHoles = function () {
return _template().default.program.ast(_templateObject45);
};
helpers.iterableToArray = function () {
return _template().default.program.ast(_templateObject46);
};
helpers.iterableToArrayLimit = function () {
return _template().default.program.ast(_templateObject47);
};
helpers.iterableToArrayLimitLoose = function () {
return _template().default.program.ast(_templateObject48);
};
helpers.nonIterableSpread = function () {
return _template().default.program.ast(_templateObject49);
};
helpers.nonIterableRest = function () {
return _template().default.program.ast(_templateObject50);
};
helpers.skipFirstGeneratorNext = function () {
return _template().default.program.ast(_templateObject51);
};
helpers.toPropertyKey = function () {
return _template().default.program.ast(_templateObject52);
};
helpers.initializerWarningHelper = function () {
return _template().default.program.ast(_templateObject53);
};
helpers.initializerDefineProperty = function () {
return _template().default.program.ast(_templateObject54);
};
helpers.applyDecoratedDescriptor = function () {
return _template().default.program.ast(_templateObject55);
};

295
node_modules/@babel/helpers/lib/index.js generated vendored Normal file
View File

@@ -0,0 +1,295 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.get = get;
exports.getDependencies = getDependencies;
exports.default = exports.list = void 0;
function _traverse() {
var data = _interopRequireDefault(require("@babel/traverse"));
_traverse = function _traverse() {
return data;
};
return data;
}
function t() {
var data = _interopRequireWildcard(require("@babel/types"));
t = function t() {
return data;
};
return data;
}
var _helpers = _interopRequireDefault(require("./helpers"));
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function makePath(path) {
var parts = [];
for (; path.parentPath; path = path.parentPath) {
parts.push(path.key);
if (path.inList) parts.push(path.listKey);
}
return parts.reverse().join(".");
}
function getHelperMetadata(file) {
var globals = new Set();
var localBindingNames = new Set();
var dependencies = new Map();
var exportName;
var exportPath;
var exportBindingAssignments = [];
var importPaths = [];
var importBindingsReferences = [];
(0, _traverse().default)(file, {
ImportDeclaration: function ImportDeclaration(child) {
var name = child.node.source.value;
if (!_helpers.default[name]) {
throw child.buildCodeFrameError("Unknown helper " + name);
}
if (child.get("specifiers").length !== 1 || !child.get("specifiers.0").isImportDefaultSpecifier()) {
throw child.buildCodeFrameError("Helpers can only import a default value");
}
var bindingIdentifier = child.node.specifiers[0].local;
dependencies.set(bindingIdentifier, name);
importPaths.push(makePath(child));
},
ExportDefaultDeclaration: function ExportDefaultDeclaration(child) {
var decl = child.get("declaration");
if (decl.isFunctionDeclaration()) {
if (!decl.node.id) {
throw decl.buildCodeFrameError("Helpers should give names to their exported func declaration");
}
exportName = decl.node.id.name;
}
exportPath = makePath(child);
},
ExportAllDeclaration: function ExportAllDeclaration(child) {
throw child.buildCodeFrameError("Helpers can only export default");
},
ExportNamedDeclaration: function ExportNamedDeclaration(child) {
throw child.buildCodeFrameError("Helpers can only export default");
},
Statement: function Statement(child) {
if (child.isModuleDeclaration()) return;
child.skip();
}
});
(0, _traverse().default)(file, {
Program: function Program(path) {
var bindings = path.scope.getAllBindings();
Object.keys(bindings).forEach(function (name) {
if (name === exportName) return;
if (dependencies.has(bindings[name].identifier)) return;
localBindingNames.add(name);
});
},
ReferencedIdentifier: function ReferencedIdentifier(child) {
var name = child.node.name;
var binding = child.scope.getBinding(name, true);
if (!binding) {
globals.add(name);
} else if (dependencies.has(binding.identifier)) {
importBindingsReferences.push(makePath(child));
}
},
AssignmentExpression: function AssignmentExpression(child) {
var left = child.get("left");
if (!(exportName in left.getBindingIdentifiers())) return;
if (!left.isIdentifier()) {
throw left.buildCodeFrameError("Only simple assignments to exports are allowed in helpers");
}
var binding = child.scope.getBinding(exportName);
if (binding && binding.scope.path.isProgram()) {
exportBindingAssignments.push(makePath(child));
}
}
});
if (!exportPath) throw new Error("Helpers must default-export something.");
exportBindingAssignments.reverse();
return {
globals: Array.from(globals),
localBindingNames: Array.from(localBindingNames),
dependencies: dependencies,
exportBindingAssignments: exportBindingAssignments,
exportPath: exportPath,
exportName: exportName,
importBindingsReferences: importBindingsReferences,
importPaths: importPaths
};
}
function permuteHelperAST(file, metadata, id, localBindings, getDependency) {
if (localBindings && !id) {
throw new Error("Unexpected local bindings for module-based helpers.");
}
if (!id) return;
var localBindingNames = metadata.localBindingNames,
dependencies = metadata.dependencies,
exportBindingAssignments = metadata.exportBindingAssignments,
exportPath = metadata.exportPath,
exportName = metadata.exportName,
importBindingsReferences = metadata.importBindingsReferences,
importPaths = metadata.importPaths;
var dependenciesRefs = {};
dependencies.forEach(function (name, id) {
dependenciesRefs[id.name] = typeof getDependency === "function" && getDependency(name) || id;
});
var toRename = {};
var bindings = new Set(localBindings || []);
localBindingNames.forEach(function (name) {
var newName = name;
while (bindings.has(newName)) {
newName = "_" + newName;
}
if (newName !== name) toRename[name] = newName;
});
if (id.type === "Identifier" && exportName !== id.name) {
toRename[exportName] = id.name;
}
(0, _traverse().default)(file, {
Program: function Program(path) {
var exp = path.get(exportPath);
var imps = importPaths.map(function (p) {
return path.get(p);
});
var impsBindingRefs = importBindingsReferences.map(function (p) {
return path.get(p);
});
var decl = exp.get("declaration");
if (id.type === "Identifier") {
if (decl.isFunctionDeclaration()) {
exp.replaceWith(decl);
} else {
exp.replaceWith(t().variableDeclaration("var", [t().variableDeclarator(id, decl.node)]));
}
} else if (id.type === "MemberExpression") {
if (decl.isFunctionDeclaration()) {
exportBindingAssignments.forEach(function (assignPath) {
var assign = path.get(assignPath);
assign.replaceWith(t().assignmentExpression("=", id, assign.node));
});
exp.replaceWith(decl);
path.pushContainer("body", t().expressionStatement(t().assignmentExpression("=", id, t().identifier(exportName))));
} else {
exp.replaceWith(t().expressionStatement(t().assignmentExpression("=", id, decl.node)));
}
} else {
throw new Error("Unexpected helper format.");
}
Object.keys(toRename).forEach(function (name) {
path.scope.rename(name, toRename[name]);
});
for (var _iterator = imps, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
var _ref;
if (_isArray) {
if (_i >= _iterator.length) break;
_ref = _iterator[_i++];
} else {
_i = _iterator.next();
if (_i.done) break;
_ref = _i.value;
}
var _path = _ref;
_path.remove();
}
for (var _iterator2 = impsBindingRefs, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
var _ref2;
if (_isArray2) {
if (_i2 >= _iterator2.length) break;
_ref2 = _iterator2[_i2++];
} else {
_i2 = _iterator2.next();
if (_i2.done) break;
_ref2 = _i2.value;
}
var _path2 = _ref2;
var node = t().cloneNode(dependenciesRefs[_path2.node.name]);
_path2.replaceWith(node);
}
path.stop();
}
});
}
var helperData = {};
function loadHelper(name) {
if (!helperData[name]) {
if (!_helpers.default[name]) throw new ReferenceError("Unknown helper " + name);
var fn = function fn() {
return t().file(_helpers.default[name]());
};
var metadata = getHelperMetadata(fn());
helperData[name] = {
build: function build(getDependency, id, localBindings) {
var file = fn();
permuteHelperAST(file, metadata, id, localBindings, getDependency);
return {
nodes: file.program.body,
globals: metadata.globals
};
},
dependencies: metadata.dependencies
};
}
return helperData[name];
}
function get(name, getDependency, id, localBindings) {
return loadHelper(name).build(getDependency, id, localBindings);
}
function getDependencies(name) {
return Array.from(loadHelper(name).dependencies.values());
}
var list = Object.keys(_helpers.default).map(function (name) {
return name.replace(/^_/, "");
}).filter(function (name) {
return name !== "__esModule";
});
exports.list = list;
var _default = get;
exports.default = _default;

50
node_modules/@babel/helpers/package.json generated vendored Normal file
View File

@@ -0,0 +1,50 @@
{
"_from": "@babel/helpers@7.0.0-beta.46",
"_id": "@babel/helpers@7.0.0-beta.46",
"_inBundle": false,
"_integrity": "sha512-mbpH9pM3pJzo/tBr75U+zva3pqpyivogt1aofgEoD7bWFAYSuqOudRuz+m4XP6VPxxLoxcA4SFPGkuLRt9+7nQ==",
"_location": "/@babel/helpers",
"_phantomChildren": {},
"_requested": {
"type": "version",
"registry": true,
"raw": "@babel/helpers@7.0.0-beta.46",
"name": "@babel/helpers",
"escapedName": "@babel%2fhelpers",
"scope": "@babel",
"rawSpec": "7.0.0-beta.46",
"saveSpec": null,
"fetchSpec": "7.0.0-beta.46"
},
"_requiredBy": [
"/@babel/core"
],
"_resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.0.0-beta.46.tgz",
"_shasum": "b5f988dfd77f4f713792cf7818b687050736ee52",
"_spec": "@babel/helpers@7.0.0-beta.46",
"_where": "/home/s2/Documents/Code/minifyfromhtml/node_modules/@babel/core",
"author": {
"name": "Sebastian McKenzie",
"email": "sebmck@gmail.com"
},
"bundleDependencies": false,
"dependencies": {
"@babel/template": "7.0.0-beta.46",
"@babel/traverse": "7.0.0-beta.46",
"@babel/types": "7.0.0-beta.46"
},
"deprecated": false,
"description": "Collection of helper functions used by Babel transforms.",
"devDependencies": {
"@babel/helper-plugin-test-runner": "7.0.0-beta.46"
},
"homepage": "https://babeljs.io/",
"license": "MIT",
"main": "lib/index.js",
"name": "@babel/helpers",
"repository": {
"type": "git",
"url": "https://github.com/babel/babel/tree/master/packages/babel-helpers"
},
"version": "7.0.0-beta.46"
}