three-stdlib 2.22.9 → 2.23.0

package/dist/nodes/display/NormalMapNode.mjs

@@ -1,54 +0,0 @@
-import TempNode from "../core/TempNode.mjs";
-import ModelNode from "../accessors/ModelNode.mjs";
-import { ShaderNode, dFdx, dFdy, cross, add, mul, max, dot, cond, equal, inversesqrt, normalize, sub, join, positionView, normalView, uv } from "../ShaderNode.mjs";
-import { TangentSpaceNormalMap, ObjectSpaceNormalMap } from "three";
-const perturbNormal2ArbNode = new ShaderNode((inputs) => {
-  const { eye_pos, surf_norm, mapN, faceDirection, uv: uv2 } = inputs;
-  const q0 = dFdx(eye_pos.xyz);
-  const q1 = dFdy(eye_pos.xyz);
-  const st0 = dFdx(uv2.st);
-  const st1 = dFdy(uv2.st);
-  const N = surf_norm;
-  const q1perp = cross(q1, N);
-  const q0perp = cross(N, q0);
-  const T = add(mul(q1perp, st0.x), mul(q0perp, st1.x));
-  const B = add(mul(q1perp, st0.y), mul(q0perp, st1.y));
-  const det = max(dot(T, T), dot(B, B));
-  const scale = cond(equal(det, 0), 0, mul(faceDirection, inversesqrt(det)));
-  return normalize(add(mul(T, mul(mapN.x, scale)), mul(B, mul(mapN.y, scale)), mul(N, mapN.z)));
-});
-class NormalMapNode extends TempNode {
-  constructor(node, scaleNode = null) {
-    super("vec3");
-    this.node = node;
-    this.scaleNode = scaleNode;
-    this.normalMapType = TangentSpaceNormalMap;
-  }
-  generate(builder) {
-    const type = this.getNodeType(builder);
-    const { normalMapType, scaleNode } = this;
-    const normalOP = mul(this.node, 2);
-    let normalMap = sub(normalOP, 1);
-    if (scaleNode !== null) {
-      const normalMapScale = mul(normalMap.xy, scaleNode);
-      normalMap = join(normalMapScale, normalMap.z);
-    }
-    if (normalMapType === ObjectSpaceNormalMap) {
-      const vertexNormalNode = mul(new ModelNode(ModelNode.NORMAL_MATRIX), normalMap);
-      const normal = normalize(vertexNormalNode);
-      return normal.build(builder, type);
-    } else if (normalMapType === TangentSpaceNormalMap) {
-      const perturbNormal2ArbCall = perturbNormal2ArbNode({
-        eye_pos: positionView,
-        surf_norm: normalView,
-        mapN: normalMap,
-        faceDirection: 1,
-        uv: uv()
-      });
-      return perturbNormal2ArbCall.build(builder, type);
-    }
-  }
-}
-export {
-  NormalMapNode as default
-};

package/dist/nodes/fog/FogNode.js

@@ -1,14 +0,0 @@
-"use strict";
-const Node = require("../core/Node.js");
-class FogNode extends Node {
-  constructor(colorNode, factorNode) {
-    super("float");
-    this.colorNode = colorNode;
-    this.factorNode = factorNode;
-  }
-  generate(builder) {
-    return this.factorNode.build(builder, "float");
-  }
-}
-FogNode.prototype.isFogNode = true;
-module.exports = FogNode;

package/dist/nodes/fog/FogNode.mjs

@@ -1,15 +0,0 @@
-import Node from "../core/Node.mjs";
-class FogNode extends Node {
-  constructor(colorNode, factorNode) {
-    super("float");
-    this.colorNode = colorNode;
-    this.factorNode = factorNode;
-  }
-  generate(builder) {
-    return this.factorNode.build(builder, "float");
-  }
-}
-FogNode.prototype.isFogNode = true;
-export {
-  FogNode as default
-};

package/dist/nodes/fog/FogRangeNode.js

@@ -1,16 +0,0 @@
-"use strict";
-const FogNode = require("./FogNode.js");
-const ShaderNode = require("../ShaderNode.js");
-class FogRangeNode extends FogNode {
-  constructor(colorNode, nearNode, farNode) {
-    super(colorNode);
-    this.nearNode = nearNode;
-    this.farNode = farNode;
-  }
-  generate(builder) {
-    this.factorNode = ShaderNode.smoothstep(this.nearNode, this.farNode, ShaderNode.negate(ShaderNode.positionView.z));
-    return super.generate(builder);
-  }
-}
-FogRangeNode.prototype.isFogRangeNode = true;
-module.exports = FogRangeNode;

package/dist/nodes/fog/FogRangeNode.mjs

@@ -1,17 +0,0 @@
-import FogNode from "./FogNode.mjs";
-import { smoothstep, negate, positionView } from "../ShaderNode.mjs";
-class FogRangeNode extends FogNode {
-  constructor(colorNode, nearNode, farNode) {
-    super(colorNode);
-    this.nearNode = nearNode;
-    this.farNode = farNode;
-  }
-  generate(builder) {
-    this.factorNode = smoothstep(this.nearNode, this.farNode, negate(positionView.z));
-    return super.generate(builder);
-  }
-}
-FogRangeNode.prototype.isFogRangeNode = true;
-export {
-  FogRangeNode as default
-};

package/dist/nodes/functions/BSDFs.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const ShaderNode = require("../ShaderNode.js");
-const F_Schlick = new ShaderNode.ShaderNode((inputs) => {
-  const { f0, f90, dotVH } = inputs;
-  const fresnel = ShaderNode.exp2(ShaderNode.mul(ShaderNode.sub(ShaderNode.mul(-5.55473, dotVH), 6.98316), dotVH));
-  return ShaderNode.add(ShaderNode.mul(f0, ShaderNode.sub(1, fresnel)), ShaderNode.mul(f90, fresnel));
-});
-const BRDF_Lambert = new ShaderNode.ShaderNode((inputs) => {
-  return ShaderNode.mul(1 / Math.PI, inputs.diffuseColor);
-});
-const getDistanceAttenuation = new ShaderNode.ShaderNode((inputs) => {
-  const { lightDistance, cutoffDistance, decayExponent } = inputs;
-  return ShaderNode.cond(
-    ShaderNode.and(ShaderNode.greaterThan(cutoffDistance, 0), ShaderNode.greaterThan(decayExponent, 0)),
-    ShaderNode.pow(ShaderNode.saturate(ShaderNode.add(ShaderNode.div(ShaderNode.negate(lightDistance), cutoffDistance), 1)), decayExponent),
-    1
-  );
-});
-const V_GGX_SmithCorrelated = new ShaderNode.ShaderNode((inputs) => {
-  const { alpha, dotNL, dotNV } = inputs;
-  const a2 = ShaderNode.pow2(alpha);
-  const gv = ShaderNode.mul(dotNL, ShaderNode.sqrt(ShaderNode.add(a2, ShaderNode.mul(ShaderNode.sub(1, a2), ShaderNode.pow2(dotNV)))));
-  const gl = ShaderNode.mul(dotNV, ShaderNode.sqrt(ShaderNode.add(a2, ShaderNode.mul(ShaderNode.sub(1, a2), ShaderNode.pow2(dotNL)))));
-  return ShaderNode.div(0.5, ShaderNode.max(ShaderNode.add(gv, gl), ShaderNode.EPSILON));
-});
-const D_GGX = new ShaderNode.ShaderNode((inputs) => {
-  const { alpha, dotNH } = inputs;
-  const a2 = ShaderNode.pow2(alpha);
-  const denom = ShaderNode.add(ShaderNode.mul(ShaderNode.pow2(dotNH), ShaderNode.sub(a2, 1)), 1);
-  return ShaderNode.mul(1 / Math.PI, ShaderNode.div(a2, ShaderNode.pow2(denom)));
-});
-const BRDF_GGX = new ShaderNode.ShaderNode((inputs) => {
-  const { lightDirection, f0, f90, roughness } = inputs;
-  const alpha = ShaderNode.pow2(roughness);
-  const halfDir = ShaderNode.normalize(ShaderNode.add(lightDirection, ShaderNode.positionViewDirection));
-  const dotNL = ShaderNode.saturate(ShaderNode.dot(ShaderNode.transformedNormalView, lightDirection));
-  const dotNV = ShaderNode.saturate(ShaderNode.dot(ShaderNode.transformedNormalView, ShaderNode.positionViewDirection));
-  const dotNH = ShaderNode.saturate(ShaderNode.dot(ShaderNode.transformedNormalView, halfDir));
-  const dotVH = ShaderNode.saturate(ShaderNode.dot(ShaderNode.positionViewDirection, halfDir));
-  const F = F_Schlick({ f0, f90, dotVH });
-  const V = V_GGX_SmithCorrelated({ alpha, dotNL, dotNV });
-  const D = D_GGX({ alpha, dotNH });
-  return ShaderNode.mul(F, ShaderNode.mul(V, D));
-});
-const RE_Direct_Physical = new ShaderNode.ShaderNode((inputs) => {
-  const { lightDirection, lightColor, directDiffuse, directSpecular } = inputs;
-  const dotNL = ShaderNode.saturate(ShaderNode.dot(ShaderNode.transformedNormalView, lightDirection));
-  let irradiance = ShaderNode.mul(dotNL, lightColor);
-  irradiance = ShaderNode.mul(irradiance, Math.PI);
-  ShaderNode.addTo(directDiffuse, ShaderNode.mul(irradiance, BRDF_Lambert({ diffuseColor: ShaderNode.diffuseColor.rgb })));
-  ShaderNode.addTo(directSpecular, ShaderNode.mul(irradiance, BRDF_GGX({ lightDirection, f0: ShaderNode.specularColor, f90: 1, roughness: ShaderNode.roughness })));
-});
-const PhysicalLightingModel = new ShaderNode.ShaderNode((inputs) => {
-  RE_Direct_Physical(inputs);
-});
-exports.BRDF_GGX = BRDF_GGX;
-exports.BRDF_Lambert = BRDF_Lambert;
-exports.D_GGX = D_GGX;
-exports.F_Schlick = F_Schlick;
-exports.PhysicalLightingModel = PhysicalLightingModel;
-exports.RE_Direct_Physical = RE_Direct_Physical;
-exports.V_GGX_SmithCorrelated = V_GGX_SmithCorrelated;
-exports.getDistanceAttenuation = getDistanceAttenuation;

package/dist/nodes/functions/BSDFs.mjs

@@ -1,64 +0,0 @@
-import { ShaderNode, exp2, mul, sub, add, cond, and, greaterThan, pow, saturate, div, negate, pow2, sqrt, max, EPSILON, normalize, positionViewDirection, dot, transformedNormalView, addTo, diffuseColor, specularColor, roughness } from "../ShaderNode.mjs";
-const F_Schlick = new ShaderNode((inputs) => {
-  const { f0, f90, dotVH } = inputs;
-  const fresnel = exp2(mul(sub(mul(-5.55473, dotVH), 6.98316), dotVH));
-  return add(mul(f0, sub(1, fresnel)), mul(f90, fresnel));
-});
-const BRDF_Lambert = new ShaderNode((inputs) => {
-  return mul(1 / Math.PI, inputs.diffuseColor);
-});
-const getDistanceAttenuation = new ShaderNode((inputs) => {
-  const { lightDistance, cutoffDistance, decayExponent } = inputs;
-  return cond(
-    and(greaterThan(cutoffDistance, 0), greaterThan(decayExponent, 0)),
-    pow(saturate(add(div(negate(lightDistance), cutoffDistance), 1)), decayExponent),
-    1
-  );
-});
-const V_GGX_SmithCorrelated = new ShaderNode((inputs) => {
-  const { alpha, dotNL, dotNV } = inputs;
-  const a2 = pow2(alpha);
-  const gv = mul(dotNL, sqrt(add(a2, mul(sub(1, a2), pow2(dotNV)))));
-  const gl = mul(dotNV, sqrt(add(a2, mul(sub(1, a2), pow2(dotNL)))));
-  return div(0.5, max(add(gv, gl), EPSILON));
-});
-const D_GGX = new ShaderNode((inputs) => {
-  const { alpha, dotNH } = inputs;
-  const a2 = pow2(alpha);
-  const denom = add(mul(pow2(dotNH), sub(a2, 1)), 1);
-  return mul(1 / Math.PI, div(a2, pow2(denom)));
-});
-const BRDF_GGX = new ShaderNode((inputs) => {
-  const { lightDirection, f0, f90, roughness: roughness2 } = inputs;
-  const alpha = pow2(roughness2);
-  const halfDir = normalize(add(lightDirection, positionViewDirection));
-  const dotNL = saturate(dot(transformedNormalView, lightDirection));
-  const dotNV = saturate(dot(transformedNormalView, positionViewDirection));
-  const dotNH = saturate(dot(transformedNormalView, halfDir));
-  const dotVH = saturate(dot(positionViewDirection, halfDir));
-  const F = F_Schlick({ f0, f90, dotVH });
-  const V = V_GGX_SmithCorrelated({ alpha, dotNL, dotNV });
-  const D = D_GGX({ alpha, dotNH });
-  return mul(F, mul(V, D));
-});
-const RE_Direct_Physical = new ShaderNode((inputs) => {
-  const { lightDirection, lightColor, directDiffuse, directSpecular } = inputs;
-  const dotNL = saturate(dot(transformedNormalView, lightDirection));
-  let irradiance = mul(dotNL, lightColor);
-  irradiance = mul(irradiance, Math.PI);
-  addTo(directDiffuse, mul(irradiance, BRDF_Lambert({ diffuseColor: diffuseColor.rgb })));
-  addTo(directSpecular, mul(irradiance, BRDF_GGX({ lightDirection, f0: specularColor, f90: 1, roughness })));
-});
-const PhysicalLightingModel = new ShaderNode((inputs) => {
-  RE_Direct_Physical(inputs);
-});
-export {
-  BRDF_GGX,
-  BRDF_Lambert,
-  D_GGX,
-  F_Schlick,
-  PhysicalLightingModel,
-  RE_Direct_Physical,
-  V_GGX_SmithCorrelated,
-  getDistanceAttenuation
-};

package/dist/nodes/lights/LightContextNode.js

@@ -1,34 +0,0 @@
-"use strict";
-const ContextNode = require("../core/ContextNode.js");
-const VarNode = require("../core/VarNode.js");
-const UniformNode = require("../core/UniformNode.js");
-const OperatorNode = require("../math/OperatorNode.js");
-const BSDFs = require("../functions/BSDFs.js");
-const THREE = require("three");
-class LightContextNode extends ContextNode {
-  constructor(node) {
-    super(node);
-  }
-  getNodeType() {
-    return "vec3";
-  }
-  generate(builder) {
-    const material = builder.material;
-    let lightingModel = null;
-    if (material.isMeshStandardMaterial === true) {
-      lightingModel = BSDFs.PhysicalLightingModel;
-    }
-    const directDiffuse = new VarNode(new UniformNode(new THREE.Vector3()), "DirectDiffuse", "vec3");
-    const directSpecular = new VarNode(new UniformNode(new THREE.Vector3()), "DirectSpecular", "vec3");
-    this.context.directDiffuse = directDiffuse;
-    this.context.directSpecular = directSpecular;
-    if (lightingModel !== null) {
-      this.context.lightingModel = lightingModel;
-    }
-    const type = this.getNodeType(builder);
-    super.generate(builder, type);
-    const totalLight = new OperatorNode("+", directDiffuse, directSpecular);
-    return totalLight.build(builder, type);
-  }
-}
-module.exports = LightContextNode;

package/dist/nodes/lights/LightContextNode.mjs

@@ -1,35 +0,0 @@
-import ContextNode from "../core/ContextNode.mjs";
-import VarNode from "../core/VarNode.mjs";
-import UniformNode from "../core/UniformNode.mjs";
-import OperatorNode from "../math/OperatorNode.mjs";
-import { PhysicalLightingModel } from "../functions/BSDFs.mjs";
-import { Vector3 } from "three";
-class LightContextNode extends ContextNode {
-  constructor(node) {
-    super(node);
-  }
-  getNodeType() {
-    return "vec3";
-  }
-  generate(builder) {
-    const material = builder.material;
-    let lightingModel = null;
-    if (material.isMeshStandardMaterial === true) {
-      lightingModel = PhysicalLightingModel;
-    }
-    const directDiffuse = new VarNode(new UniformNode(new Vector3()), "DirectDiffuse", "vec3");
-    const directSpecular = new VarNode(new UniformNode(new Vector3()), "DirectSpecular", "vec3");
-    this.context.directDiffuse = directDiffuse;
-    this.context.directSpecular = directSpecular;
-    if (lightingModel !== null) {
-      this.context.lightingModel = lightingModel;
-    }
-    const type = this.getNodeType(builder);
-    super.generate(builder, type);
-    const totalLight = new OperatorNode("+", directDiffuse, directSpecular);
-    return totalLight.build(builder, type);
-  }
-}
-export {
-  LightContextNode as default
-};

package/dist/nodes/lights/LightNode.js

@@ -1,57 +0,0 @@
-"use strict";
-const Node = require("../core/Node.js");
-const Object3DNode = require("../accessors/Object3DNode.js");
-const PositionNode = require("../accessors/PositionNode.js");
-const UniformNode = require("../core/UniformNode.js");
-const OperatorNode = require("../math/OperatorNode.js");
-const MathNode = require("../math/MathNode.js");
-const constants = require("../core/constants.js");
-const BSDFs = require("../functions/BSDFs.js");
-const THREE = require("three");
-class LightNode extends Node {
-  constructor(light = null) {
-    super("vec3");
-    this.updateType = constants.NodeUpdateType.Object;
-    this.light = light;
-    this._colorNode = new UniformNode(new THREE.Color());
-    this._lightCutoffDistanceNode = new UniformNode(0);
-    this._lightDecayExponentNode = new UniformNode(0);
-  }
-  getHash() {
-    return this.light.uuid;
-  }
-  update() {
-    this._colorNode.value.copy(this.light.color).multiplyScalar(this.light.intensity);
-    this._lightCutoffDistanceNode.value = this.light.distance;
-    this._lightDecayExponentNode.value = this.light.decay;
-  }
-  generate(builder) {
-    const lightPositionView = new Object3DNode(Object3DNode.VIEW_POSITION);
-    const positionView = new PositionNode(PositionNode.VIEW);
-    const lVector = new OperatorNode("-", lightPositionView, positionView);
-    const lightDirection = new MathNode(MathNode.NORMALIZE, lVector);
-    const lightDistance = new MathNode(MathNode.LENGTH, lVector);
-    const lightAttenuation = BSDFs.getDistanceAttenuation({
-      lightDistance,
-      cutoffDistance: this._lightCutoffDistanceNode,
-      decayExponent: this._lightDecayExponentNode
-    });
-    const lightColor = new OperatorNode("*", this._colorNode, lightAttenuation);
-    lightPositionView.object3d = this.light;
-    const lightingModelFunction = builder.context.lightingModel;
-    if (lightingModelFunction !== void 0) {
-      const directDiffuse = builder.context.directDiffuse;
-      const directSpecular = builder.context.directSpecular;
-      lightingModelFunction(
-        {
-          lightDirection,
-          lightColor,
-          directDiffuse,
-          directSpecular
-        },
-        builder
-      );
-    }
-  }
-}
-module.exports = LightNode;

package/dist/nodes/lights/LightNode.mjs

@@ -1,58 +0,0 @@
-import Node from "../core/Node.mjs";
-import Object3DNode from "../accessors/Object3DNode.mjs";
-import PositionNode from "../accessors/PositionNode.mjs";
-import UniformNode from "../core/UniformNode.mjs";
-import OperatorNode from "../math/OperatorNode.mjs";
-import MathNode from "../math/MathNode.mjs";
-import { NodeUpdateType } from "../core/constants.mjs";
-import { getDistanceAttenuation } from "../functions/BSDFs.mjs";
-import { Color } from "three";
-class LightNode extends Node {
-  constructor(light = null) {
-    super("vec3");
-    this.updateType = NodeUpdateType.Object;
-    this.light = light;
-    this._colorNode = new UniformNode(new Color());
-    this._lightCutoffDistanceNode = new UniformNode(0);
-    this._lightDecayExponentNode = new UniformNode(0);
-  }
-  getHash() {
-    return this.light.uuid;
-  }
-  update() {
-    this._colorNode.value.copy(this.light.color).multiplyScalar(this.light.intensity);
-    this._lightCutoffDistanceNode.value = this.light.distance;
-    this._lightDecayExponentNode.value = this.light.decay;
-  }
-  generate(builder) {
-    const lightPositionView = new Object3DNode(Object3DNode.VIEW_POSITION);
-    const positionView = new PositionNode(PositionNode.VIEW);
-    const lVector = new OperatorNode("-", lightPositionView, positionView);
-    const lightDirection = new MathNode(MathNode.NORMALIZE, lVector);
-    const lightDistance = new MathNode(MathNode.LENGTH, lVector);
-    const lightAttenuation = getDistanceAttenuation({
-      lightDistance,
-      cutoffDistance: this._lightCutoffDistanceNode,
-      decayExponent: this._lightDecayExponentNode
-    });
-    const lightColor = new OperatorNode("*", this._colorNode, lightAttenuation);
-    lightPositionView.object3d = this.light;
-    const lightingModelFunction = builder.context.lightingModel;
-    if (lightingModelFunction !== void 0) {
-      const directDiffuse = builder.context.directDiffuse;
-      const directSpecular = builder.context.directSpecular;
-      lightingModelFunction(
-        {
-          lightDirection,
-          lightColor,
-          directDiffuse,
-          directSpecular
-        },
-        builder
-      );
-    }
-  }
-}
-export {
-  LightNode as default
-};

package/dist/nodes/lights/LightsNode.js

@@ -1,58 +0,0 @@
-"use strict";
-const Node = require("../core/Node.js");
-const LightNode = require("./LightNode.js");
-const sortLights = (lights) => {
-  return lights.sort((a, b) => a.id - b.id);
-};
-class LightsNode extends Node {
-  constructor(lightNodes = []) {
-    super("vec3");
-    this.lightNodes = lightNodes;
-    this._hash = null;
-  }
-  get hasLight() {
-    return this.lightNodes.length > 0;
-  }
-  generate(builder) {
-    const lightNodes = this.lightNodes;
-    for (const lightNode of lightNodes) {
-      lightNode.build(builder);
-    }
-    return "vec3( 0.0 )";
-  }
-  getHash() {
-    if (this._hash === null) {
-      let hash = "";
-      const lightNodes = this.lightNodes;
-      for (const lightNode of lightNodes) {
-        hash += lightNode.light.uuid + " ";
-      }
-      this._hash = hash;
-    }
-    return this._hash;
-  }
-  getLightNodeByHash(hash) {
-    const lightNodes = this.lightNodes;
-    for (const lightNode of lightNodes) {
-      if (lightNode.light.uuid === hash) {
-        return lightNode;
-      }
-    }
-    return null;
-  }
-  fromLights(lights) {
-    const lightNodes = [];
-    lights = sortLights(lights);
-    for (const light of lights) {
-      let lightNode = this.getLightNodeByHash(light.uuid);
-      if (lightNode === null) {
-        lightNode = new LightNode(light);
-      }
-      lightNodes.push(lightNode);
-    }
-    this.lightNodes = lightNodes;
-    this._hash = null;
-    return this;
-  }
-}
-module.exports = LightsNode;

package/dist/nodes/lights/LightsNode.mjs

@@ -1,59 +0,0 @@
-import Node from "../core/Node.mjs";
-import LightNode from "./LightNode.mjs";
-const sortLights = (lights) => {
-  return lights.sort((a, b) => a.id - b.id);
-};
-class LightsNode extends Node {
-  constructor(lightNodes = []) {
-    super("vec3");
-    this.lightNodes = lightNodes;
-    this._hash = null;
-  }
-  get hasLight() {
-    return this.lightNodes.length > 0;
-  }
-  generate(builder) {
-    const lightNodes = this.lightNodes;
-    for (const lightNode of lightNodes) {
-      lightNode.build(builder);
-    }
-    return "vec3( 0.0 )";
-  }
-  getHash() {
-    if (this._hash === null) {
-      let hash = "";
-      const lightNodes = this.lightNodes;
-      for (const lightNode of lightNodes) {
-        hash += lightNode.light.uuid + " ";
-      }
-      this._hash = hash;
-    }
-    return this._hash;
-  }
-  getLightNodeByHash(hash) {
-    const lightNodes = this.lightNodes;
-    for (const lightNode of lightNodes) {
-      if (lightNode.light.uuid === hash) {
-        return lightNode;
-      }
-    }
-    return null;
-  }
-  fromLights(lights) {
-    const lightNodes = [];
-    lights = sortLights(lights);
-    for (const light of lights) {
-      let lightNode = this.getLightNodeByHash(light.uuid);
-      if (lightNode === null) {
-        lightNode = new LightNode(light);
-      }
-      lightNodes.push(lightNode);
-    }
-    this.lightNodes = lightNodes;
-    this._hash = null;
-    return this;
-  }
-}
-export {
-  LightsNode as default
-};