@jilib/ji/dist/ji/symbols/import.symbol.js

Ji Language — Symbols as Functions

"use strict";

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

var _set = require("./set.symbol");

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

var importSymbol =
/*#__PURE__*/
function () {
  var _ref = _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee2(left, right) {
    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            return _context2.abrupt("return",
            /*#__PURE__*/
            function () {
              var _ref2 = _asyncToGenerator(
              /*#__PURE__*/
              regeneratorRuntime.mark(function _callee(state) {
                var isLiteral, foldedContext, madeContext, res, transport, currentSymbols, newSymbols, addSymbols, output, collected;
                return regeneratorRuntime.wrap(function _callee$(_context) {
                  while (1) {
                    switch (_context.prev = _context.next) {
                      case 0:
                        isLiteral = left === '!';
                        foldedContext = (0, _set.contextFolder)(state.context);
                        madeContext = (0, _set.contextMaker)(state.context);
                        _context.next = 5;
                        return Function("".concat(madeContext, "\n return ").concat(right)).bind(_objectSpread({}, foldedContext))();

                      case 5:
                        res = _context.sent;
                        transport = res.transport;
                        currentSymbols = Object.keys(state.vocabulary);
                        newSymbols = !!transport && !!transport.vocabulary && Object.entries(transport.vocabulary).filter(function (_ref3) {
                          var _ref4 = _slicedToArray(_ref3, 1),
                              symbol = _ref4[0];

                          return currentSymbols.indexOf(symbol) === -1;
                        });
                        addSymbols = newSymbols.reduce(function (acc, _ref5) {
                          var _ref6 = _slicedToArray(_ref5, 2),
                              symbol = _ref6[0],
                              fn = _ref6[1];

                          return _objectSpread({}, acc, _defineProperty({}, symbol, fn));
                        }, {});
                        output = isLiteral ? "".concat(state.output, "\nNew symbols: ").concat(newSymbols.map(function (_ref7) {
                          var _ref8 = _slicedToArray(_ref7, 1),
                              e = _ref8[0];

                          return e;
                        }).join(', '), "\n") : state.output;
                        collected = '';
                        return _context.abrupt("return", newSymbols.length > 0 ? _objectSpread({}, state, {
                          vocabulary: _objectSpread({}, state.vocabulary, {}, addSymbols),
                          output: output,
                          collected: collected
                        }) : _objectSpread({}, state, {
                          output: output,
                          collected: collected
                        }));

                      case 13:
                      case "end":
                        return _context.stop();
                    }
                  }
                }, _callee);
              }));

              return function (_x3) {
                return _ref2.apply(this, arguments);
              };
            }());

          case 1:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));

  return function importSymbol(_x, _x2) {
    return _ref.apply(this, arguments);
  };
}();

exports.importSymbol = importSymbol;
var _default = importSymbol;
exports["default"] = _default;