service-flow-designer 0.0.1-beta.1 → 0.0.1-beta.2

package/dist/lib/node_modules/.pnpm/@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/Kernel.js

@@ -0,0 +1,282 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index$1 = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/regenerator/index.js");
+const asyncToGenerator = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js");
+const defineProperty = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/defineProperty.js");
+const initializerDefineProperty = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/initializerDefineProperty.js");
+const classCallCheck = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js");
+const createClass = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js");
+const applyDecoratedDescriptor = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js");
+const index = require("../../../../../@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/index.js");
+require("../../../../../@webgpu_types@0.0.31/node_modules/@webgpu/types/dist/constants.js");
+require("../../../../../inversify@5.1.1/node_modules/inversify/es/container/container.js");
+const injectable = require("../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/injectable.js");
+require("../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata.js");
+const inject = require("../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/inject.js");
+require("../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata_reader.js");
+const canvas = require("./utils/canvas.js");
+const isArray = require("./utils/is-array.js");
+const isNumber = require("./utils/is-number.js");
+const isTypedarray = require("./utils/is-typedarray.js");
+const constants = require("../../../../../../../_virtual/constants.js");
+const identifier = require("../../../../../@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/identifier.js");
+const Entity = require("../../../../../@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/Entity.js");
+var _dec, _dec2, _dec3, _class, _class2, _descriptor, _descriptor2, _temp;
+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(Object(source), true).forEach(function(key) {
+        defineProperty(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+var Kernel = (_dec = injectable.injectable(), _dec2 = inject.inject(identifier.IDENTIFIER.RenderEngine), _dec3 = inject.inject(identifier.IDENTIFIER.ConfigService), _dec(_class = (_class2 = (_temp = /* @__PURE__ */ function() {
+  function Kernel2() {
+    classCallCheck(this, Kernel2);
+    initializerDefineProperty(this, "engine", _descriptor, this);
+    initializerDefineProperty(this, "configService", _descriptor2, this);
+    this.entity = Entity.createEntity();
+    this.model = void 0;
+    this.dirty = true;
+    this.compiledBundle = void 0;
+    this.initPromise = void 0;
+  }
+  createClass(Kernel2, [{
+    key: "init",
+    value: function init() {
+      var _this$configService$g = this.configService.get(), canvas$1 = _this$configService$g.canvas, engineOptions = _this$configService$g.engineOptions;
+      this.initPromise = this.engine.init(_objectSpread({
+        canvas: canvas$1 || canvas.createCanvas(),
+        swapChainFormat: constants.__exports.TextureFormat.BGRA8Unorm,
+        antialiasing: false
+      }, engineOptions));
+    }
+  }, {
+    key: "setBundle",
+    value: function setBundle(bundle) {
+      this.compiledBundle = JSON.parse(JSON.stringify(bundle));
+    }
+  }, {
+    key: "setDispatch",
+    value: function setDispatch(dispatch) {
+      if (this.compiledBundle.context) {
+        this.compiledBundle.context.dispatch = dispatch;
+      }
+      return this;
+    }
+  }, {
+    key: "setMaxIteration",
+    value: function setMaxIteration(maxIteration) {
+      if (this.compiledBundle.context) {
+        this.compiledBundle.context.maxIteration = maxIteration;
+      }
+      return this;
+    }
+  }, {
+    key: "setBinding",
+    value: function setBinding(name, data) {
+      var _this = this;
+      if (typeof name === "string") {
+        var isNumberLikeData = isNumber.isNumber(data) || isTypedarray.isTypedArray(data) || isArray(data);
+        if (this.compiledBundle && this.compiledBundle.context) {
+          var existedDefine = this.compiledBundle.context.defines.find(function(b) {
+            return b.name === name;
+          });
+          if (existedDefine) {
+            existedDefine.value = data;
+            return this;
+          }
+          var existedBinding = this.compiledBundle.context.uniforms.find(function(b) {
+            return b.name === name;
+          });
+          if (existedBinding) {
+            if (isNumberLikeData) {
+              existedBinding.data = data;
+              existedBinding.isReferer = false;
+              if (existedBinding.storageClass === index.STORAGE_CLASS.Uniform) {
+                if (this.model) {
+                  this.model.updateUniform(name, data);
+                }
+              } else {
+                if (this.model) {
+                  this.model.updateBuffer(name, data);
+                }
+              }
+            } else {
+              existedBinding.isReferer = true;
+              existedBinding.data = data;
+            }
+          }
+        }
+      } else {
+        Object.keys(name).forEach(function(key) {
+          _this.setBinding(key, name[key]);
+        });
+      }
+      return this;
+    }
+  }, {
+    key: "execute",
+    value: function() {
+      var _execute = asyncToGenerator(/* @__PURE__ */ index$1.mark(function _callee() {
+        var _this2 = this;
+        var iteration, i, _args = arguments;
+        return index$1.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                iteration = _args.length > 0 && _args[0] !== void 0 ? _args[0] : 1;
+                if (!this.dirty) {
+                  _context.next = 6;
+                  break;
+                }
+                if (this.compiledBundle.context) {
+                  if (iteration > 1) {
+                    this.compiledBundle.context.maxIteration = iteration;
+                  } else {
+                    this.compiledBundle.context.maxIteration++;
+                  }
+                }
+                _context.next = 5;
+                return this.compile();
+              case 5:
+                this.dirty = false;
+              case 6:
+                this.engine.beginFrame();
+                this.engine.clear({});
+                if (this.compiledBundle.context) {
+                  this.compiledBundle.context.uniforms.filter(function(_ref) {
+                    var isReferer = _ref.isReferer;
+                    return isReferer;
+                  }).forEach(function(_ref2) {
+                    var data = _ref2.data, name = _ref2.name;
+                    _this2.model.confirmInput(data.model, name);
+                  });
+                }
+                for (i = 0; i < iteration; i++) {
+                  this.model.run();
+                }
+                this.engine.endFrame();
+                return _context.abrupt("return", this);
+              case 12:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+      function execute() {
+        return _execute.apply(this, arguments);
+      }
+      return execute;
+    }()
+    /**
+     * read output from GPUBuffer
+     */
+  }, {
+    key: "getOutput",
+    value: function() {
+      var _getOutput = asyncToGenerator(/* @__PURE__ */ index$1.mark(function _callee2() {
+        return index$1.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                return _context2.abrupt("return", this.model.readData());
+              case 1:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function getOutput() {
+        return _getOutput.apply(this, arguments);
+      }
+      return getOutput;
+    }()
+  }, {
+    key: "compile",
+    value: function() {
+      var _compile = asyncToGenerator(/* @__PURE__ */ index$1.mark(function _callee3() {
+        var context, target, shader;
+        return index$1.wrap(function _callee3$(_context3) {
+          while (1) {
+            switch (_context3.prev = _context3.next) {
+              case 0:
+                _context3.next = 2;
+                return this.initPromise;
+              case 2:
+                context = _objectSpread({}, this.compiledBundle.context);
+                target = this.engine.supportWebGPU ? this.engine.useWGSL ? index.Target.WGSL : index.Target.GLSL450 : index.Target.GLSL100;
+                shader = this.compiledBundle.shaders[target];
+                context.defines.filter(function(define) {
+                  return define.runtime;
+                }).forEach(function(define) {
+                  var valuePlaceHolder = "".concat(index.DefineValuePlaceholder).concat(define.name);
+                  shader = shader.replace(valuePlaceHolder, "".concat(define.value));
+                });
+                context.shader = shader;
+                context.uniforms.forEach(function(uniform) {
+                  if (!uniform.data) {
+                    if (uniform.storageClass === index.STORAGE_CLASS.StorageBuffer) {
+                      var sizePerElement = 1;
+                      if (uniform.type === index.AST_TOKEN_TYPES.FloatArray) {
+                        sizePerElement = 1;
+                      } else if (uniform.type === index.AST_TOKEN_TYPES.Vector4FloatArray) {
+                        sizePerElement = 4;
+                      }
+                      uniform.data = new Float32Array(context.output.length * sizePerElement).fill(0);
+                    }
+                  }
+                });
+                this.compiledBundle.context = context;
+                _context3.next = 11;
+                return this.engine.createComputeModel(this.compiledBundle.context);
+              case 11:
+                this.model = _context3.sent;
+              case 12:
+              case "end":
+                return _context3.stop();
+            }
+          }
+        }, _callee3, this);
+      }));
+      function compile() {
+        return _compile.apply(this, arguments);
+      }
+      return compile;
+    }()
+  }]);
+  return Kernel2;
+}(), _temp), _descriptor = applyDecoratedDescriptor(_class2.prototype, "engine", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = applyDecoratedDescriptor(_class2.prototype, "configService", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _class2)) || _class);
+exports.Kernel = Kernel;

package/dist/lib/node_modules/.pnpm/@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/Renderer.js

@@ -0,0 +1,302 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/regenerator/index.js");
+const asyncToGenerator = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/asyncToGenerator.js");
+const initializerDefineProperty = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/initializerDefineProperty.js");
+const classCallCheck = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js");
+const createClass = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js");
+const applyDecoratedDescriptor = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/applyDecoratedDescriptor.js");
+require("../../../../../@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/index.js");
+require("../../../../../@webgpu_types@0.0.31/node_modules/@webgpu/types/dist/constants.js");
+require("../../../../../inversify@5.1.1/node_modules/inversify/es/container/container.js");
+const injectable = require("../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/injectable.js");
+require("../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata.js");
+const inject = require("../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/inject.js");
+require("../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata_reader.js");
+const identifier = require("../../../../../@antv_g-webgpu-core@0.5.6/node_modules/@antv/g-webgpu-core/es/identifier.js");
+const constants = require("../../../../../../../_virtual/constants.js");
+var _dec, _dec2, _dec3, _dec4, _class, _class2, _descriptor, _descriptor2, _descriptor3, _temp;
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it;
+  if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike) {
+      if (it) o = it;
+      var i = 0;
+      var F = function F2() {
+      };
+      return { s: F, n: function n() {
+        if (i >= o.length) return { done: true };
+        return { done: false, value: o[i++] };
+      }, e: function e(_e) {
+        throw _e;
+      }, f: F };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true, didErr = false, err;
+  return { s: function s() {
+    it = o[Symbol.iterator]();
+  }, n: function n() {
+    var step = it.next();
+    normalCompletion = step.done;
+    return step;
+  }, e: function e(_e2) {
+    didErr = true;
+    err = _e2;
+  }, f: function f() {
+    try {
+      if (!normalCompletion && it.return != null) it.return();
+    } finally {
+      if (didErr) throw err;
+    }
+  } };
+}
+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);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+  return arr2;
+}
+var mapFragDeclaration = "#ifdef USE_MAP\n  uniform sampler2D map;\n#endif";
+var mapFragMain = "#ifdef USE_MAP\n  vec4 texelColor = texture2D(map, vUv);\n  // texelColor = mapTexelToLinear(texelColor);\n  diffuseColor *= texelColor;\n#endif";
+var uvFragDeclaration = "#if (defined( USE_UV ) && ! defined( UVS_VERTEX_ONLY ))\n  varying vec2 vUv;\n#endif";
+var uvVertDeclaration = "#ifdef USE_UV\n  attribute vec2 uv;\n	#ifdef UVS_VERTEX_ONLY\n    vec2 vUv;\n	#else\n		varying vec2 vUv;\n	#endif\n	uniform mat3 uvTransform;\n#endif";
+var uvVertMain = "#ifdef USE_UV\n  vUv = (uvTransform * vec3(uv, 1)).xy;\n#endif";
+var Renderer = (_dec = injectable.injectable(), _dec2 = inject.inject(identifier.IDENTIFIER.RenderEngine), _dec3 = inject.inject(identifier.IDENTIFIER.ShaderModuleService), _dec4 = inject.inject(identifier.IDENTIFIER.ConfigService), _dec(_class = (_class2 = (_temp = /* @__PURE__ */ function() {
+  function Renderer2() {
+    classCallCheck(this, Renderer2);
+    this.container = void 0;
+    initializerDefineProperty(this, "engine", _descriptor, this);
+    initializerDefineProperty(this, "shaderModule", _descriptor2, this);
+    initializerDefineProperty(this, "configService", _descriptor3, this);
+    this.inited = false;
+    this.rendering = false;
+    this.pendings = [];
+    this.views = [];
+    this.size = void 0;
+  }
+  createClass(Renderer2, [{
+    key: "init",
+    value: function() {
+      var _init = asyncToGenerator(/* @__PURE__ */ index.mark(function _callee() {
+        var systems, config, _iterator, _step, system;
+        return index.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                this.shaderModule.registerBuiltinModules();
+                this.shaderModule.registerModule("uv.vert.declaration", {
+                  vs: uvVertDeclaration
+                });
+                this.shaderModule.registerModule("uv.vert.main", {
+                  vs: uvVertMain
+                });
+                this.shaderModule.registerModule("uv.frag.declaration", {
+                  fs: uvFragDeclaration
+                });
+                this.shaderModule.registerModule("map.frag.declaration", {
+                  fs: mapFragDeclaration
+                });
+                this.shaderModule.registerModule("map.frag.main", {
+                  fs: mapFragMain
+                });
+                systems = this.container.getAll(identifier.IDENTIFIER.Systems);
+                config = this.configService.get();
+                if (!config.canvas) {
+                  _context.next = 30;
+                  break;
+                }
+                _context.next = 11;
+                return this.engine.init({
+                  canvas: config.canvas,
+                  swapChainFormat: constants.__exports.TextureFormat.BGRA8Unorm,
+                  antialiasing: false
+                });
+              case 11:
+                _iterator = _createForOfIteratorHelper(systems);
+                _context.prev = 12;
+                _iterator.s();
+              case 14:
+                if ((_step = _iterator.n()).done) {
+                  _context.next = 21;
+                  break;
+                }
+                system = _step.value;
+                if (!system.initialize) {
+                  _context.next = 19;
+                  break;
+                }
+                _context.next = 19;
+                return system.initialize();
+              case 19:
+                _context.next = 14;
+                break;
+              case 21:
+                _context.next = 26;
+                break;
+              case 23:
+                _context.prev = 23;
+                _context.t0 = _context["catch"](12);
+                _iterator.e(_context.t0);
+              case 26:
+                _context.prev = 26;
+                _iterator.f();
+                return _context.finish(26);
+              case 29:
+                this.inited = true;
+              case 30:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this, [[12, 23, 26, 29]]);
+      }));
+      function init() {
+        return _init.apply(this, arguments);
+      }
+      return init;
+    }()
+  }, {
+    key: "render",
+    value: function() {
+      var _render = asyncToGenerator(/* @__PURE__ */ index.mark(function _callee2() {
+        var systems, _len, views, _key, _iterator2, _step2, system, _args2 = arguments;
+        return index.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!(!this.inited || this.rendering)) {
+                  _context2.next = 2;
+                  break;
+                }
+                return _context2.abrupt("return");
+              case 2:
+                if (this.pendings.length) {
+                  this.pendings.forEach(function(pending) {
+                    pending();
+                  });
+                }
+                this.rendering = true;
+                this.engine.beginFrame();
+                systems = this.container.getAll(identifier.IDENTIFIER.Systems);
+                for (_len = _args2.length, views = new Array(_len), _key = 0; _key < _len; _key++) {
+                  views[_key] = _args2[_key];
+                }
+                _iterator2 = _createForOfIteratorHelper(systems);
+                _context2.prev = 8;
+                _iterator2.s();
+              case 10:
+                if ((_step2 = _iterator2.n()).done) {
+                  _context2.next = 17;
+                  break;
+                }
+                system = _step2.value;
+                if (!system.execute) {
+                  _context2.next = 15;
+                  break;
+                }
+                _context2.next = 15;
+                return system.execute(views);
+              case 15:
+                _context2.next = 10;
+                break;
+              case 17:
+                _context2.next = 22;
+                break;
+              case 19:
+                _context2.prev = 19;
+                _context2.t0 = _context2["catch"](8);
+                _iterator2.e(_context2.t0);
+              case 22:
+                _context2.prev = 22;
+                _iterator2.f();
+                return _context2.finish(22);
+              case 25:
+                this.engine.endFrame();
+                this.rendering = false;
+              case 27:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this, [[8, 19, 22, 25]]);
+      }));
+      function render() {
+        return _render.apply(this, arguments);
+      }
+      return render;
+    }()
+  }, {
+    key: "clear",
+    value: function clear(options) {
+      var _this = this;
+      if (this.inited) {
+        this.engine.clear(options);
+      } else {
+        this.pendings.unshift(function() {
+          _this.engine.clear(options);
+          _this.pendings.shift();
+        });
+      }
+      return this;
+    }
+    // public setScissor(
+    //   scissor: Partial<{
+    //     enable: boolean;
+    //     box: {
+    //       x: number;
+    //       y: number;
+    //       width: number;
+    //       height: number;
+    //     };
+    //   }>,
+    // ) {
+    //   this.engine.setScissor(scissor);
+    //   return this;
+    // }
+  }, {
+    key: "setSize",
+    value: function setSize(_ref) {
+      var width = _ref.width, height = _ref.height;
+      var canvas = this.engine.getCanvas();
+      this.size = {
+        width,
+        height
+      };
+      canvas.width = width;
+      canvas.height = height;
+      return this;
+    }
+  }, {
+    key: "getSize",
+    value: function getSize() {
+      return this.size;
+    }
+  }]);
+  return Renderer2;
+}(), _temp), _descriptor = applyDecoratedDescriptor(_class2.prototype, "engine", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = applyDecoratedDescriptor(_class2.prototype, "shaderModule", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = applyDecoratedDescriptor(_class2.prototype, "configService", [_dec4], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _class2)) || _class);
+exports.Renderer = Renderer;

package/dist/lib/node_modules/.pnpm/@antv_g-webgpu@0.5.5/node_modules/@antv/g-webgpu/es/Scene.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const classCallCheck = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/classCallCheck.js");
+const createClass = require("../../../../../@babel_runtime@7.24.7/node_modules/@babel/runtime/helpers/esm/createClass.js");
+require("../../../../../inversify@5.1.1/node_modules/inversify/es/container/container.js");
+const injectable = require("../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/injectable.js");
+require("../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata.js");
+require("../../../../../inversify@5.1.1/node_modules/inversify/es/annotation/inject.js");
+require("../../../../../inversify@5.1.1/node_modules/inversify/es/planning/metadata_reader.js");
+var _dec, _class, _temp;
+var Scene = (_dec = injectable.injectable(), _dec(_class = (_temp = /* @__PURE__ */ function() {
+  function Scene2() {
+    classCallCheck(this, Scene2);
+    this.entities = [];
+  }
+  createClass(Scene2, [{
+    key: "getEntities",
+    value: function getEntities() {
+      return this.entities;
+    }
+  }, {
+    key: "addRenderable",
+    value: function addRenderable(renderable) {
+      this.addEntity(renderable.getEntity());
+      return this;
+    }
+  }, {
+    key: "removeRenderable",
+    value: function removeRenderable(renderable) {
+      this.removeEntity(renderable.getEntity());
+      return this;
+    }
+  }, {
+    key: "addLight",
+    value: function addLight() {
+    }
+  }, {
+    key: "addEntity",
+    value: function addEntity(entity) {
+      if (this.entities.indexOf(entity) === -1) {
+        this.entities.push(entity);
+      }
+      return this;
+    }
+  }, {
+    key: "removeEntity",
+    value: function removeEntity(entity) {
+      var index = this.entities.indexOf(entity);
+      this.entities.splice(index, 1);
+      return this;
+    }
+  }]);
+  return Scene2;
+}(), _temp)) || _class);
+exports.Scene = Scene;