module.exports =
/******/ (() => { // webpackBootstrap
/******/ 	"use strict";
/******/ 	var __webpack_modules__ = ({

/***/ 461:
/***/ ((__unused_webpack_module, exports) => {



Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.declare = declare;

function declare(builder) {
  return (api, options, dirname) => {
    var _clonedApi2;

    let clonedApi;

    for (const name of Object.keys(apiPolyfills)) {
      var _clonedApi;

      if (api[name]) continue;
      clonedApi = (_clonedApi = clonedApi) != null ? _clonedApi : copyApiObject(api);
      clonedApi[name] = apiPolyfills[name](clonedApi);
    }

    return builder((_clonedApi2 = clonedApi) != null ? _clonedApi2 : api, options || {}, dirname);
  };
}

const apiPolyfills = {
  assertVersion: api => range => {
    throwVersionError(range, api.version);
  },
  targets: () => () => {
    return {};
  },
  assumption: () => () => {}
};

function copyApiObject(api) {
  let proto = null;

  if (typeof api.version === "string" && /^7\./.test(api.version)) {
    proto = Object.getPrototypeOf(api);

    if (proto && (!has(proto, "version") || !has(proto, "transform") || !has(proto, "template") || !has(proto, "types"))) {
      proto = null;
    }
  }

  return Object.assign({}, proto, api);
}

function has(obj, key) {
  return Object.prototype.hasOwnProperty.call(obj, key);
}

function throwVersionError(range, version) {
  if (typeof range === "number") {
    if (!Number.isInteger(range)) {
      throw new Error("Expected string or integer value.");
    }

    range = `^${range}.0.0-0`;
  }

  if (typeof range !== "string") {
    throw new Error("Expected string or integer value.");
  }

  const limit = Error.stackTraceLimit;

  if (typeof limit === "number" && limit < 25) {
    Error.stackTraceLimit = 25;
  }

  let err;

  if (version.slice(0, 2) === "7.") {
    err = new Error(`Requires Babel "^7.0.0-beta.41", but was loaded with "${version}". ` + `You'll need to update your @babel/core version.`);
  } else {
    err = new Error(`Requires Babel "${range}", but was loaded with "${version}". ` + `If you are sure you have a compatible version of @babel/core, ` + `it is likely that something in your build process is loading the ` + `wrong version. Inspect the stack trace of this error to look for ` + `the first entry that doesn't mention "@babel/core" or "babel-core" ` + `to see what is calling Babel.`);
  }

  if (typeof limit === "number") {
    Error.stackTraceLimit = limit;
  }

  throw Object.assign(err, {
    code: "BABEL_VERSION_UNSUPPORTED",
    version,
    range
  });
}

/***/ }),

/***/ 189:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {



Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.default = void 0;

var _core = __nccwpck_require__(928);

const buildOptimizedSequenceExpression = ({
  assign,
  call,
  path
}) => {
  const {
    left: placeholderNode,
    right: pipelineLeft
  } = assign;
  const {
    callee: calledExpression
  } = call;
  let optimizeArrow = _core.types.isArrowFunctionExpression(calledExpression) && _core.types.isExpression(calledExpression.body) && !calledExpression.async && !calledExpression.generator;
  let param;

  if (optimizeArrow) {
    const {
      params
    } = calledExpression;

    if (params.length === 1 && _core.types.isIdentifier(params[0])) {
      param = params[0];
    } else if (params.length > 0) {
      optimizeArrow = false;
    }
  } else if (_core.types.isIdentifier(calledExpression, {
    name: "eval"
  })) {
    const evalSequence = _core.types.sequenceExpression([_core.types.numericLiteral(0), calledExpression]);

    call.callee = evalSequence;
    path.scope.push({
      id: _core.types.cloneNode(placeholderNode)
    });
    return _core.types.sequenceExpression([assign, call]);
  }

  if (optimizeArrow && !param) {
    return _core.types.sequenceExpression([pipelineLeft, calledExpression.body]);
  }

  path.scope.push({
    id: _core.types.cloneNode(placeholderNode)
  });

  if (param) {
    path.get("right").scope.rename(param.name, placeholderNode.name);
    return _core.types.sequenceExpression([assign, calledExpression.body]);
  }

  return _core.types.sequenceExpression([assign, call]);
};

var _default = buildOptimizedSequenceExpression;
exports.default = _default;

/***/ }),

/***/ 184:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {



Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.default = void 0;

var _core = __nccwpck_require__(928);

var _buildOptimizedSequenceExpression = _interopRequireDefault(__nccwpck_require__(189));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const fsharpVisitor = {
  BinaryExpression(path) {
    const {
      scope,
      node
    } = path;
    const {
      operator,
      left,
      right
    } = node;
    if (operator !== "|>") return;
    const placeholder = scope.generateUidIdentifierBasedOnNode(left);
    const call = right.type === "AwaitExpression" ? _core.types.awaitExpression(_core.types.cloneNode(placeholder)) : _core.types.callExpression(right, [_core.types.cloneNode(placeholder)]);
    const sequence = (0, _buildOptimizedSequenceExpression.default)({
      assign: _core.types.assignmentExpression("=", _core.types.cloneNode(placeholder), left),
      call,
      path
    });
    path.replaceWith(sequence);
  }

};
var _default = fsharpVisitor;
exports.default = _default;

/***/ }),

/***/ 541:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {



Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.default = void 0;

var _helperPluginUtils = __nccwpck_require__(461);

var _pluginSyntaxPipelineOperator = _interopRequireDefault(__nccwpck_require__(986));

var _minimalVisitor = _interopRequireDefault(__nccwpck_require__(968));

var _smartVisitor = _interopRequireDefault(__nccwpck_require__(558));

var _fsharpVisitor = _interopRequireDefault(__nccwpck_require__(184));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const visitorsPerProposal = {
  minimal: _minimalVisitor.default,
  smart: _smartVisitor.default,
  fsharp: _fsharpVisitor.default
};

var _default = (0, _helperPluginUtils.declare)((api, options) => {
  api.assertVersion(7);
  return {
    name: "proposal-pipeline-operator",
    inherits: _pluginSyntaxPipelineOperator.default,
    visitor: visitorsPerProposal[options.proposal]
  };
});

exports.default = _default;

/***/ }),

/***/ 968:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {



Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.default = void 0;

var _core = __nccwpck_require__(928);

var _buildOptimizedSequenceExpression = _interopRequireDefault(__nccwpck_require__(189));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

const minimalVisitor = {
  BinaryExpression(path) {
    const {
      scope,
      node
    } = path;
    const {
      operator,
      left,
      right
    } = node;
    if (operator !== "|>") return;
    const placeholder = scope.generateUidIdentifierBasedOnNode(left);

    const call = _core.types.callExpression(right, [_core.types.cloneNode(placeholder)]);

    path.replaceWith((0, _buildOptimizedSequenceExpression.default)({
      assign: _core.types.assignmentExpression("=", _core.types.cloneNode(placeholder), left),
      call,
      path
    }));
  }

};
var _default = minimalVisitor;
exports.default = _default;

/***/ }),

/***/ 558:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {



Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.default = void 0;

var _core = __nccwpck_require__(928);

const updateTopicReferenceVisitor = {
  PipelinePrimaryTopicReference(path) {
    path.replaceWith(_core.types.cloneNode(this.topicId));
  },

  PipelineTopicExpression(path) {
    path.skip();
  }

};
const smartVisitor = {
  BinaryExpression(path) {
    const {
      scope
    } = path;
    const {
      node
    } = path;
    const {
      operator,
      left,
      right
    } = node;
    if (operator !== "|>") return;
    const placeholder = scope.generateUidIdentifierBasedOnNode(left);
    scope.push({
      id: placeholder
    });
    let call;

    if (_core.types.isPipelineTopicExpression(right)) {
      path.get("right").traverse(updateTopicReferenceVisitor, {
        topicId: placeholder
      });
      call = right.expression;
    } else {
      let callee = right.callee;

      if (_core.types.isIdentifier(callee, {
        name: "eval"
      })) {
        callee = _core.types.sequenceExpression([_core.types.numericLiteral(0), callee]);
      }

      call = _core.types.callExpression(callee, [_core.types.cloneNode(placeholder)]);
    }

    path.replaceWith(_core.types.sequenceExpression([_core.types.assignmentExpression("=", _core.types.cloneNode(placeholder), left), call]));
  }

};
var _default = smartVisitor;
exports.default = _default;

/***/ }),

/***/ 986:
/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {



Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.default = exports.proposals = void 0;

var _helperPluginUtils = __nccwpck_require__(461);

const proposals = ["minimal", "smart", "fsharp"];
exports.proposals = proposals;

var _default = (0, _helperPluginUtils.declare)((api, {
  proposal
}) => {
  api.assertVersion(7);

  if (typeof proposal !== "string" || !proposals.includes(proposal)) {
    throw new Error("The pipeline operator plugin requires a 'proposal' option." + "'proposal' must be one of: " + proposals.join(", ") + ". More details: https://babeljs.io/docs/en/next/babel-plugin-proposal-pipeline-operator");
  }

  return {
    name: "syntax-pipeline-operator",

    manipulateOptions(opts, parserOpts) {
      parserOpts.plugins.push(["pipelineOperator", {
        proposal
      }]);
    }

  };
});

exports.default = _default;

/***/ }),

/***/ 928:
/***/ ((module) => {

module.exports = require("@builder/pack/@babel/core");;

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __nccwpck_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		if(__webpack_module_cache__[moduleId]) {
/******/ 			return __webpack_module_cache__[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		var threw = true;
/******/ 		try {
/******/ 			__webpack_modules__[moduleId](module, module.exports, __nccwpck_require__);
/******/ 			threw = false;
/******/ 		} finally {
/******/ 			if(threw) delete __webpack_module_cache__[moduleId];
/******/ 		}
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/compat */
/******/ 	
/******/ 	__nccwpck_require__.ab = __dirname + "/";/************************************************************************/
/******/ 	// module exports must be returned from runtime so entry inlining is disabled
/******/ 	// startup
/******/ 	// Load entry module and return exports
/******/ 	return __nccwpck_require__(541);
/******/ })()
;