(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define(["exports", "three", "../nodes/Nodes.js"], factory);
  } else if (typeof exports !== "undefined") {
    factory(exports, require("three"), require("../nodes/Nodes.js"));
  } else {
    var mod = {
      exports: {}
    };
    factory(mod.exports, global.three, global.Nodes);
    global.NodeMaterialLoader = mod.exports;
  }
})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, Nodes) {
  "use strict";

  Object.defineProperty(_exports, "__esModule", {
    value: true
  });
  _exports.NodeMaterialLoaderUtils = _exports.NodeMaterialLoader = void 0;
  Nodes = _interopRequireWildcard(Nodes);

  function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

  function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }

  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }

  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

  var NodeMaterialLoader = /*#__PURE__*/function (_Loader) {
    _inherits(NodeMaterialLoader, _Loader);

    var _super = _createSuper(NodeMaterialLoader);

    function NodeMaterialLoader(manager) {
      var _this;

      var library = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, NodeMaterialLoader);

      _this = _super.call(this, manager);
      _this.nodes = {};
      _this.materials = {};
      _this.passes = {};
      _this.names = {};
      _this.library = library;
      return _this;
    }

    _createClass(NodeMaterialLoader, [{
      key: "load",
      value: function load(url, onLoad, onProgress, onError) {
        var scope = this;
        var loader = new _three.FileLoader(scope.manager);
        loader.setPath(scope.path);
        loader.load(url, function (text) {
          onLoad(scope.parse(JSON.parse(text)));
        }, onProgress, onError);
        return this;
      }
    }, {
      key: "getObjectByName",
      value: function getObjectByName(uuid) {
        return this.names[uuid];
      }
    }, {
      key: "getObjectById",
      value: function getObjectById(uuid) {
        return this.library[uuid] || this.nodes[uuid] || this.materials[uuid] || this.passes[uuid] || this.names[uuid];
      }
    }, {
      key: "getNode",
      value: function getNode(uuid) {
        var object = this.getObjectById(uuid);

        if (!object) {
          console.warn('Node "' + uuid + '" not found.');
        }

        return object;
      }
    }, {
      key: "resolve",
      value: function resolve(json) {
        switch (typeof json) {
          case 'boolean':
          case 'number':
            return json;

          case 'string':
            if (/^\w{8}-\w{4}-\w{4}-\w{4}-\w{12}$/i.test(json) || this.library[json]) {
              return this.getNode(json);
            }

            return json;

          default:
            if (Array.isArray(json)) {
              for (var i = 0; i < json.length; i++) {
                json[i] = this.resolve(json[i]);
              }
            } else {
              for (var prop in json) {
                if (prop === 'uuid') continue;
                json[prop] = this.resolve(json[prop]);
              }
            }

        }

        return json;
      }
    }, {
      key: "declare",
      value: function declare(json) {
        var uuid, node, object;

        for (uuid in json.nodes) {
          node = json.nodes[uuid];
          object = new Nodes[node.nodeType + 'Node']();

          if (node.name) {
            object.name = node.name;
            this.names[object.name] = object;
          }

          this.nodes[uuid] = object;
        }

        for (uuid in json.materials) {
          node = json.materials[uuid];
          object = new Nodes[node.type]();

          if (node.name) {
            object.name = node.name;
            this.names[object.name] = object;
          }

          this.materials[uuid] = object;
        }

        for (uuid in json.passes) {
          node = json.passes[uuid];
          object = new Nodes[node.type]();

          if (node.name) {
            object.name = node.name;
            this.names[object.name] = object;
          }

          this.passes[uuid] = object;
        }

        if (json.material) this.material = this.materials[json.material];
        if (json.pass) this.pass = this.passes[json.pass];
        return json;
      }
    }, {
      key: "parse",
      value: function parse(json) {
        var uuid;
        json = this.resolve(this.declare(json));

        for (uuid in json.nodes) {
          this.nodes[uuid].copy(json.nodes[uuid]);
        }

        for (uuid in json.materials) {
          this.materials[uuid].copy(json.materials[uuid]);
        }

        for (uuid in json.passes) {
          this.passes[uuid].copy(json.passes[uuid]);
        }

        return this.material || this.pass || this;
      }
    }]);

    return NodeMaterialLoader;
  }(_three.Loader);

  _exports.NodeMaterialLoader = NodeMaterialLoader;

  var NodeMaterialLoaderUtils = /*#__PURE__*/function () {
    function NodeMaterialLoaderUtils() {
      _classCallCheck(this, NodeMaterialLoaderUtils);
    }

    _createClass(NodeMaterialLoaderUtils, null, [{
      key: "replaceUUIDObject",
      value: function replaceUUIDObject(object, uuid, value, recursive) {
        recursive = recursive !== undefined ? recursive : true;
        if (typeof uuid === 'object') uuid = uuid.uuid;

        if (typeof object === 'object') {
          var keys = Object.keys(object);

          for (var i = 0; i < keys.length; i++) {
            var key = keys[i];

            if (recursive) {
              object[key] = this.replaceUUIDObject(object[key], uuid, value);
            }

            if (key === uuid) {
              object[uuid] = object[key];
              delete object[key];
            }
          }
        }

        return object === uuid ? value : object;
      }
    }, {
      key: "replaceUUID",
      value: function replaceUUID(json, uuid, value) {
        this.replaceUUIDObject(json, uuid, value, false);
        this.replaceUUIDObject(json.nodes, uuid, value);
        this.replaceUUIDObject(json.materials, uuid, value);
        this.replaceUUIDObject(json.passes, uuid, value);
        this.replaceUUIDObject(json.library, uuid, value, false);
        return json;
      }
    }]);

    return NodeMaterialLoaderUtils;
  }();

  _exports.NodeMaterialLoaderUtils = NodeMaterialLoaderUtils;
});