@spiffcommerce/preview 3.6.2-rc.4 → 3.6.2-rc.5

package/dist/node_modules/@babylonjs/core/Engines/Extensions/engine.uniformBuffer.esm.js

@@ -0,0 +1,29 @@
+import { ThinEngine as t } from "../thinEngine.esm.js";
+import { WebGLDataBuffer as e } from "../../Meshes/WebGL/webGLDataBuffer.esm.js";
+t.prototype.createUniformBuffer = function(i) {
+  const f = this._gl.createBuffer();
+  if (!f)
+    throw new Error("Unable to create uniform buffer");
+  const r = new e(f);
+  return this.bindUniformBuffer(r), i instanceof Float32Array ? this._gl.bufferData(this._gl.UNIFORM_BUFFER, i, this._gl.STATIC_DRAW) : this._gl.bufferData(this._gl.UNIFORM_BUFFER, new Float32Array(i), this._gl.STATIC_DRAW), this.bindUniformBuffer(null), r.references = 1, r;
+};
+t.prototype.createDynamicUniformBuffer = function(i) {
+  const f = this._gl.createBuffer();
+  if (!f)
+    throw new Error("Unable to create dynamic uniform buffer");
+  const r = new e(f);
+  return this.bindUniformBuffer(r), i instanceof Float32Array ? this._gl.bufferData(this._gl.UNIFORM_BUFFER, i, this._gl.DYNAMIC_DRAW) : this._gl.bufferData(this._gl.UNIFORM_BUFFER, new Float32Array(i), this._gl.DYNAMIC_DRAW), this.bindUniformBuffer(null), r.references = 1, r;
+};
+t.prototype.updateUniformBuffer = function(i, f, r, n) {
+  this.bindUniformBuffer(i), r === void 0 && (r = 0), n === void 0 ? f instanceof Float32Array ? this._gl.bufferSubData(this._gl.UNIFORM_BUFFER, r, f) : this._gl.bufferSubData(this._gl.UNIFORM_BUFFER, r, new Float32Array(f)) : f instanceof Float32Array ? this._gl.bufferSubData(this._gl.UNIFORM_BUFFER, 0, f.subarray(r, r + n)) : this._gl.bufferSubData(this._gl.UNIFORM_BUFFER, 0, new Float32Array(f).subarray(r, r + n)), this.bindUniformBuffer(null);
+};
+t.prototype.bindUniformBuffer = function(i) {
+  this._gl.bindBuffer(this._gl.UNIFORM_BUFFER, i ? i.underlyingResource : null);
+};
+t.prototype.bindUniformBufferBase = function(i, f, r) {
+  this._gl.bindBufferBase(this._gl.UNIFORM_BUFFER, f, i ? i.underlyingResource : null);
+};
+t.prototype.bindUniformBlock = function(i, f, r) {
+  const n = i.program, o = this._gl.getUniformBlockIndex(n, f);
+  o !== 4294967295 && this._gl.uniformBlockBinding(n, o, r);
+};

package/dist/node_modules/@babylonjs/core/Engines/Extensions/engine.views.esm.js

@@ -0,0 +1,85 @@
+import { Engine as s } from "../engine.esm.js";
+import { Observable as c } from "../../Misc/observable.esm.js";
+const l = new c(), u = new c();
+Object.defineProperty(s.prototype, "onBeforeViewRenderObservable", {
+  get: function() {
+    return l;
+  }
+});
+Object.defineProperty(s.prototype, "onAfterViewRenderObservable", {
+  get: function() {
+    return u;
+  }
+});
+Object.defineProperty(s.prototype, "inputElement", {
+  get: function() {
+    return this._inputElement;
+  },
+  set: function(t) {
+    var e;
+    this._inputElement !== t && (this._inputElement = t, (e = this._onEngineViewChanged) === null || e === void 0 || e.call(this));
+  }
+});
+s.prototype.getInputElement = function() {
+  return this.inputElement || this.getRenderingCanvas();
+};
+s.prototype.registerView = function(t, e, i) {
+  this.views || (this.views = []);
+  for (const h of this.views)
+    if (h.target === t)
+      return h;
+  const n = this.getRenderingCanvas();
+  n && (t.width = n.width, t.height = n.height);
+  const o = { target: t, camera: e, clearBeforeCopy: i, enabled: !0, id: (Math.random() * 1e5).toFixed() };
+  return this.views.push(o), e && e.onDisposeObservable.add(() => {
+    this.unRegisterView(t);
+  }), o;
+};
+s.prototype.unRegisterView = function(t) {
+  if (!this.views || this.views.length === 0)
+    return this;
+  for (const e of this.views)
+    if (e.target === t) {
+      const i = this.views.indexOf(e);
+      i !== -1 && this.views.splice(i, 1);
+      break;
+    }
+  return this;
+};
+s.prototype._renderViewStep = function(t) {
+  const e = t.target, i = e.getContext("2d");
+  if (!i)
+    return !0;
+  const n = this.getRenderingCanvas();
+  l.notifyObservers(t);
+  const o = t.camera;
+  let h = null, r = null;
+  if (o) {
+    if (r = o.getScene(), !r || r.activeCameras && r.activeCameras.length)
+      return !0;
+    this.activeView = t, h = r.activeCamera, r.activeCamera = o;
+  }
+  if (t.customResize)
+    t.customResize(e);
+  else {
+    const a = Math.floor(e.clientWidth / this._hardwareScalingLevel), f = Math.floor(e.clientHeight / this._hardwareScalingLevel), d = a !== e.width || n.width !== e.width || f !== e.height || n.height !== e.height;
+    e.clientWidth && e.clientHeight && d && (e.width = a, e.height = f, this.setSize(a, f));
+  }
+  return !n.width || !n.height ? !1 : (this._renderFrame(), this.flushFramebuffer(), t.clearBeforeCopy && i.clearRect(0, 0, n.width, n.height), i.drawImage(n, 0, 0), h && r && (r.activeCamera = h), u.notifyObservers(t), !0);
+};
+s.prototype._renderViews = function() {
+  if (!this.views || this.views.length === 0 || !this.getRenderingCanvas())
+    return !1;
+  let e;
+  for (const i of this.views) {
+    if (!i.enabled)
+      continue;
+    if (i.target === this.inputElement) {
+      e = i;
+      continue;
+    }
+    if (!this._renderViewStep(i))
+      return !1;
+  }
+  return e && !this._renderViewStep(e) ? !1 : (this.activeView = null, !0);
+};

package/dist/node_modules/@babylonjs/core/Engines/Processors/Expressions/Operators/shaderDefineAndOperator.esm.js

@@ -0,0 +1,9 @@
+import { ShaderDefineExpression as r } from "../shaderDefineExpression.esm.js";
+class n extends r {
+  isTrue(e) {
+    return this.leftOperand.isTrue(e) && this.rightOperand.isTrue(e);
+  }
+}
+export {
+  n as ShaderDefineAndOperator
+};

package/dist/node_modules/@babylonjs/core/Engines/Processors/Expressions/Operators/shaderDefineArithmeticOperator.esm.js

@@ -0,0 +1,36 @@
+import { ShaderDefineExpression as i } from "../shaderDefineExpression.esm.js";
+class o extends i {
+  constructor(a, r, e) {
+    super(), this.define = a, this.operand = r, this.testValue = e;
+  }
+  isTrue(a) {
+    let r = a[this.define];
+    r === void 0 && (r = this.define);
+    let e = !1;
+    const t = parseInt(r), s = parseInt(this.testValue);
+    switch (this.operand) {
+      case ">":
+        e = t > s;
+        break;
+      case "<":
+        e = t < s;
+        break;
+      case "<=":
+        e = t <= s;
+        break;
+      case ">=":
+        e = t >= s;
+        break;
+      case "==":
+        e = t === s;
+        break;
+      case "!=":
+        e = t !== s;
+        break;
+    }
+    return e;
+  }
+}
+export {
+  o as ShaderDefineArithmeticOperator
+};

package/dist/node_modules/@babylonjs/core/Engines/Processors/Expressions/Operators/shaderDefineIsDefinedOperator.esm.js

@@ -0,0 +1,13 @@
+import { ShaderDefineExpression as n } from "../shaderDefineExpression.esm.js";
+class s extends n {
+  constructor(i, e = !1) {
+    super(), this.define = i, this.not = e;
+  }
+  isTrue(i) {
+    let e = i[this.define] !== void 0;
+    return this.not && (e = !e), e;
+  }
+}
+export {
+  s as ShaderDefineIsDefinedOperator
+};

package/dist/node_modules/@babylonjs/core/Engines/Processors/Expressions/Operators/shaderDefineOrOperator.esm.js

@@ -0,0 +1,9 @@
+import { ShaderDefineExpression as r } from "../shaderDefineExpression.esm.js";
+class n extends r {
+  isTrue(e) {
+    return this.leftOperand.isTrue(e) || this.rightOperand.isTrue(e);
+  }
+}
+export {
+  n as ShaderDefineOrOperator
+};

package/dist/node_modules/@babylonjs/core/Engines/Processors/Expressions/shaderDefineExpression.esm.js

@@ -0,0 +1,88 @@
+class t {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isTrue(o) {
+    return !0;
+  }
+  static postfixToInfix(o) {
+    const c = [];
+    for (const s of o)
+      if (t._OperatorPriority[s] === void 0)
+        c.push(s);
+      else {
+        const e = c[c.length - 1], u = c[c.length - 2];
+        c.length -= 2, c.push(`(${u}${s}${e})`);
+      }
+    return c[c.length - 1];
+  }
+  /**
+   * Converts an infix expression to a postfix expression.
+   *
+   * This method is used to transform infix expressions, which are more human-readable,
+   * into postfix expressions, also known as Reverse Polish Notation (RPN), that can be
+   * evaluated more efficiently by a computer. The conversion is based on the operator
+   * priority defined in _OperatorPriority.
+   *
+   * The function employs a stack-based algorithm for the conversion and caches the result
+   * to improve performance. The cache keeps track of each converted expression's access time
+   * to manage the cache size and optimize memory usage. When the cache size exceeds a specified
+   * limit, the least recently accessed items in the cache are deleted.
+   *
+   * The cache mechanism is particularly helpful for shader compilation, where the same infix
+   * expressions might be encountered repeatedly, hence the caching can speed up the process.
+   *
+   * @param infix - The infix expression to be converted.
+   * @returns The postfix expression as an array of strings.
+   */
+  static infixToPostfix(o) {
+    const c = t._InfixToPostfixCache.get(o);
+    if (c)
+      return c.accessTime = Date.now(), c.result;
+    if (!o.includes("&&") && !o.includes("||") && !o.includes(")") && !o.includes("("))
+      return [o];
+    const s = [];
+    let e = -1;
+    const u = () => {
+      l = l.trim(), l !== "" && (s.push(l), l = "");
+    }, P = (i) => {
+      e < t._Stack.length - 1 && (t._Stack[++e] = i);
+    }, h = () => t._Stack[e], r = () => e === -1 ? "!!INVALID EXPRESSION!!" : t._Stack[e--];
+    let a = 0, l = "";
+    for (; a < o.length; ) {
+      const i = o.charAt(a), C = a < o.length - 1 ? o.substr(a, 2) : "";
+      if (i === "(")
+        l = "", P(i);
+      else if (i === ")") {
+        for (u(); e !== -1 && h() !== "("; )
+          s.push(r());
+        r();
+      } else if (t._OperatorPriority[C] > 1) {
+        for (u(); e !== -1 && t._OperatorPriority[h()] >= t._OperatorPriority[C]; )
+          s.push(r());
+        P(C), a++;
+      } else
+        l += i;
+      a++;
+    }
+    for (u(); e !== -1; )
+      h() === "(" ? r() : s.push(r());
+    return t._InfixToPostfixCache.size >= t.InfixToPostfixCacheLimitSize && t.ClearCache(), t._InfixToPostfixCache.set(o, { result: s, accessTime: Date.now() }), s;
+  }
+  static ClearCache() {
+    const o = Array.from(t._InfixToPostfixCache.entries()).sort((c, s) => c[1].accessTime - s[1].accessTime);
+    for (let c = 0; c < t.InfixToPostfixCacheCleanupSize; c++)
+      t._InfixToPostfixCache.delete(o[c][0]);
+  }
+}
+t.InfixToPostfixCacheLimitSize = 5e4;
+t.InfixToPostfixCacheCleanupSize = 25e3;
+t._InfixToPostfixCache = /* @__PURE__ */ new Map();
+t._OperatorPriority = {
+  ")": 0,
+  "(": 1,
+  "||": 2,
+  "&&": 3
+};
+t._Stack = ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", ""];
+export {
+  t as ShaderDefineExpression
+};

package/dist/node_modules/@babylonjs/core/Engines/Processors/shaderCodeConditionNode.esm.js

@@ -0,0 +1,14 @@
+import { ShaderCodeNode as n } from "./shaderCodeNode.esm.js";
+class s extends n {
+  process(d, i) {
+    for (let e = 0; e < this.children.length; e++) {
+      const o = this.children[e];
+      if (o.isValid(d))
+        return o.process(d, i);
+    }
+    return "";
+  }
+}
+export {
+  s as ShaderCodeConditionNode
+};

package/dist/node_modules/@babylonjs/core/Engines/Processors/shaderCodeCursor.esm.js

@@ -0,0 +1,44 @@
+class r {
+  constructor() {
+    this._lines = [];
+  }
+  get currentLine() {
+    return this._lines[this.lineIndex];
+  }
+  get canRead() {
+    return this.lineIndex < this._lines.length - 1;
+  }
+  set lines(h) {
+    this._lines.length = 0;
+    for (const e of h) {
+      if (!e || e === "\r")
+        continue;
+      if (e[0] === "#") {
+        this._lines.push(e);
+        continue;
+      }
+      const i = e.trim();
+      if (!i)
+        continue;
+      if (i.startsWith("//")) {
+        this._lines.push(e);
+        continue;
+      }
+      const l = i.indexOf(";");
+      if (l === -1)
+        this._lines.push(i);
+      else if (l === i.length - 1)
+        i.length > 1 && this._lines.push(i);
+      else {
+        const s = e.split(";");
+        for (let t = 0; t < s.length; t++) {
+          let n = s[t];
+          n && (n = n.trim(), n && this._lines.push(n + (t !== s.length - 1 ? ";" : "")));
+        }
+      }
+    }
+  }
+}
+export {
+  r as ShaderCodeCursor
+};

package/dist/node_modules/@babylonjs/core/Engines/Processors/shaderCodeNode.esm.js

@@ -0,0 +1,31 @@
+const d = "attribute", h = "varying";
+class x {
+  constructor() {
+    this.children = [];
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  isValid(s) {
+    return !0;
+  }
+  process(s, e) {
+    var t, o, n, f, l, a, u;
+    let c = "";
+    if (this.line) {
+      let i = this.line;
+      const r = e.processor;
+      if (r) {
+        r.lineProcessor && (i = r.lineProcessor(i, e.isFragment, e.processingContext));
+        const g = (o = (t = e.processor) === null || t === void 0 ? void 0 : t.attributeKeywordName) !== null && o !== void 0 ? o : d, m = e.isFragment && (!((n = e.processor) === null || n === void 0) && n.varyingFragmentKeywordName) ? (f = e.processor) === null || f === void 0 ? void 0 : f.varyingFragmentKeywordName : !e.isFragment && (!((l = e.processor) === null || l === void 0) && l.varyingVertexKeywordName) ? (a = e.processor) === null || a === void 0 ? void 0 : a.varyingVertexKeywordName : h;
+        !e.isFragment && r.attributeProcessor && this.line.startsWith(g) ? i = r.attributeProcessor(this.line, s, e.processingContext) : r.varyingProcessor && (!((u = r.varyingCheck) === null || u === void 0) && u.call(r, this.line, e.isFragment) || !r.varyingCheck && this.line.startsWith(m)) ? i = r.varyingProcessor(this.line, e.isFragment, s, e.processingContext) : r.uniformProcessor && r.uniformRegexp && r.uniformRegexp.test(this.line) ? e.lookForClosingBracketForUniformBuffer || (i = r.uniformProcessor(this.line, e.isFragment, s, e.processingContext)) : r.uniformBufferProcessor && r.uniformBufferRegexp && r.uniformBufferRegexp.test(this.line) ? e.lookForClosingBracketForUniformBuffer || (i = r.uniformBufferProcessor(this.line, e.isFragment, e.processingContext), e.lookForClosingBracketForUniformBuffer = !0) : r.textureProcessor && r.textureRegexp && r.textureRegexp.test(this.line) ? i = r.textureProcessor(this.line, e.isFragment, s, e.processingContext) : (r.uniformProcessor || r.uniformBufferProcessor) && this.line.startsWith("uniform") && !e.lookForClosingBracketForUniformBuffer && (/uniform\s+(?:(?:highp)?|(?:lowp)?)\s*(\S+)\s+(\S+)\s*;/.test(this.line) ? r.uniformProcessor && (i = r.uniformProcessor(this.line, e.isFragment, s, e.processingContext)) : r.uniformBufferProcessor && (i = r.uniformBufferProcessor(this.line, e.isFragment, e.processingContext), e.lookForClosingBracketForUniformBuffer = !0)), e.lookForClosingBracketForUniformBuffer && this.line.indexOf("}") !== -1 && (e.lookForClosingBracketForUniformBuffer = !1, r.endOfUniformBufferProcessor && (i = r.endOfUniformBufferProcessor(this.line, e.isFragment, e.processingContext)));
+      }
+      c += i + `\r
+`;
+    }
+    return this.children.forEach((i) => {
+      c += i.process(s, e);
+    }), this.additionalDefineKey && (s[this.additionalDefineKey] = this.additionalDefineValue || "true"), c;
+  }
+}
+export {
+  x as ShaderCodeNode
+};

package/dist/node_modules/@babylonjs/core/Engines/Processors/shaderCodeTestNode.esm.js

@@ -0,0 +1,9 @@
+import { ShaderCodeNode as s } from "./shaderCodeNode.esm.js";
+class o extends s {
+  isValid(e) {
+    return this.testExpression.isTrue(e);
+  }
+}
+export {
+  o as ShaderCodeTestNode
+};

package/dist/node_modules/@babylonjs/core/Engines/Processors/shaderProcessor.esm.js

@@ -0,0 +1,230 @@
+import { ShaderCodeNode as S } from "./shaderCodeNode.esm.js";
+import { ShaderCodeCursor as F } from "./shaderCodeCursor.esm.js";
+import { ShaderCodeConditionNode as v } from "./shaderCodeConditionNode.esm.js";
+import { ShaderCodeTestNode as L } from "./shaderCodeTestNode.esm.js";
+import { ShaderDefineIsDefinedOperator as g } from "./Expressions/Operators/shaderDefineIsDefinedOperator.esm.js";
+import { ShaderDefineOrOperator as b } from "./Expressions/Operators/shaderDefineOrOperator.esm.js";
+import { ShaderDefineAndOperator as y } from "./Expressions/Operators/shaderDefineAndOperator.esm.js";
+import { ShaderDefineExpression as N } from "./Expressions/shaderDefineExpression.esm.js";
+import { ShaderDefineArithmeticOperator as B } from "./Expressions/Operators/shaderDefineArithmeticOperator.esm.js";
+import { _WarnImport as D } from "../../Misc/devTools.esm.js";
+import { ShaderLanguage as w } from "../../Materials/shaderLanguage.esm.js";
+const M = /defined\s*?\((.+?)\)/g, C = /defined\s*?\[(.+?)\]/g, R = /#include\s?<(.+)>(\((.*)\))*(\[(.*)\])*/g, A = /__decl__/, E = /light\{X\}.(\w*)/g, I = /\{X\}/g, _ = [];
+class m {
+  static Initialize(r) {
+    r.processor && r.processor.initializeShaders && r.processor.initializeShaders(r.processingContext);
+  }
+  static Process(r, e, s, t) {
+    var i;
+    !((i = e.processor) === null || i === void 0) && i.preProcessShaderCode && (r = e.processor.preProcessShaderCode(r, e.isFragment)), this._ProcessIncludes(r, e, (n) => {
+      e.processCodeAfterIncludes && (n = e.processCodeAfterIncludes(e.isFragment ? "fragment" : "vertex", n));
+      const o = this._ProcessShaderConversion(n, e, t);
+      s(o, n);
+    });
+  }
+  static PreProcess(r, e, s, t) {
+    var i;
+    !((i = e.processor) === null || i === void 0) && i.preProcessShaderCode && (r = e.processor.preProcessShaderCode(r, e.isFragment)), this._ProcessIncludes(r, e, (n) => {
+      e.processCodeAfterIncludes && (n = e.processCodeAfterIncludes(e.isFragment ? "fragment" : "vertex", n));
+      const o = this._ApplyPreProcessing(n, e, t);
+      s(o, n);
+    });
+  }
+  static Finalize(r, e, s) {
+    return !s.processor || !s.processor.finalizeShaders ? { vertexCode: r, fragmentCode: e } : s.processor.finalizeShaders(r, e, s.processingContext);
+  }
+  static _ProcessPrecision(r, e) {
+    var s;
+    if (!((s = e.processor) === null || s === void 0) && s.noPrecision)
+      return r;
+    const t = e.shouldUseHighPrecisionShader;
+    return r.indexOf("precision highp float") === -1 ? t ? r = `precision highp float;
+` + r : r = `precision mediump float;
+` + r : t || (r = r.replace("precision highp float", "precision mediump float")), r;
+  }
+  static _ExtractOperation(r) {
+    const s = /defined\((.+)\)/.exec(r);
+    if (s && s.length)
+      return new g(s[1].trim(), r[0] === "!");
+    const t = ["==", "!=", ">=", "<=", "<", ">"];
+    let i = "", n = 0;
+    for (i of t)
+      if (n = r.indexOf(i), n > -1)
+        break;
+    if (n === -1)
+      return new g(r);
+    const o = r.substring(0, n).trim(), c = r.substring(n + i.length).trim();
+    return new B(o, i, c);
+  }
+  static _BuildSubExpression(r) {
+    r = r.replace(M, "defined[$1]");
+    const e = N.infixToPostfix(r), s = [];
+    for (const i of e)
+      if (i !== "||" && i !== "&&")
+        s.push(i);
+      else if (s.length >= 2) {
+        let n = s[s.length - 1], o = s[s.length - 2];
+        s.length -= 2;
+        const c = i == "&&" ? new y() : new b();
+        typeof n == "string" && (n = n.replace(C, "defined($1)")), typeof o == "string" && (o = o.replace(C, "defined($1)")), c.leftOperand = typeof o == "string" ? this._ExtractOperation(o) : o, c.rightOperand = typeof n == "string" ? this._ExtractOperation(n) : n, s.push(c);
+      }
+    let t = s[s.length - 1];
+    return typeof t == "string" && (t = t.replace(C, "defined($1)")), typeof t == "string" ? this._ExtractOperation(t) : t;
+  }
+  static _BuildExpression(r, e) {
+    const s = new L(), t = r.substring(0, e);
+    let i = r.substring(e);
+    return i = i.substring(0, (i.indexOf("//") + 1 || i.length + 1) - 1).trim(), t === "#ifdef" ? s.testExpression = new g(i) : t === "#ifndef" ? s.testExpression = new g(i, !0) : s.testExpression = this._BuildSubExpression(i), s;
+  }
+  static _MoveCursorWithinIf(r, e, s) {
+    let t = r.currentLine;
+    for (; this._MoveCursor(r, s); ) {
+      t = r.currentLine;
+      const i = t.substring(0, 5).toLowerCase();
+      if (i === "#else") {
+        const n = new S();
+        e.children.push(n), this._MoveCursor(r, n);
+        return;
+      } else if (i === "#elif") {
+        const n = this._BuildExpression(t, 5);
+        e.children.push(n), s = n;
+      }
+    }
+  }
+  static _MoveCursor(r, e) {
+    for (; r.canRead; ) {
+      r.lineIndex++;
+      const s = r.currentLine;
+      if (s.indexOf("#") >= 0) {
+        const i = m._MoveCursorRegex.exec(s);
+        if (i && i.length) {
+          switch (i[0]) {
+            case "#ifdef": {
+              const o = new v();
+              e.children.push(o);
+              const c = this._BuildExpression(s, 6);
+              o.children.push(c), this._MoveCursorWithinIf(r, o, c);
+              break;
+            }
+            case "#else":
+            case "#elif":
+              return !0;
+            case "#endif":
+              return !1;
+            case "#ifndef": {
+              const o = new v();
+              e.children.push(o);
+              const c = this._BuildExpression(s, 7);
+              o.children.push(c), this._MoveCursorWithinIf(r, o, c);
+              break;
+            }
+            case "#if": {
+              const o = new v(), c = this._BuildExpression(s, 3);
+              e.children.push(o), o.children.push(c), this._MoveCursorWithinIf(r, o, c);
+              break;
+            }
+          }
+          continue;
+        }
+      }
+      const t = new S();
+      if (t.line = s, e.children.push(t), s[0] === "#" && s[1] === "d") {
+        const i = s.replace(";", "").split(" ");
+        t.additionalDefineKey = i[1], i.length === 3 && (t.additionalDefineValue = i[2]);
+      }
+    }
+    return !1;
+  }
+  static _EvaluatePreProcessors(r, e, s) {
+    const t = new S(), i = new F();
+    return i.lineIndex = -1, i.lines = r.split(`
+`), this._MoveCursor(i, t), t.process(e, s);
+  }
+  static _PreparePreProcessors(r, e) {
+    var s;
+    const t = r.defines, i = {};
+    for (const n of t) {
+      const c = n.replace("#define", "").replace(";", "").trim().split(" ");
+      i[c[0]] = c.length > 1 ? c[1] : "";
+    }
+    return ((s = r.processor) === null || s === void 0 ? void 0 : s.shaderLanguage) === w.GLSL && (i.GL_ES = "true"), i.__VERSION__ = r.version, i[r.platformName] = "true", e._getGlobalDefines(i), i;
+  }
+  static _ProcessShaderConversion(r, e, s) {
+    let t = this._ProcessPrecision(r, e);
+    if (!e.processor || e.processor.shaderLanguage === w.GLSL && t.indexOf("#version 3") !== -1 && (t = t.replace("#version 300 es", ""), !e.processor.parseGLES3))
+      return t;
+    const i = e.defines, n = this._PreparePreProcessors(e, s);
+    return e.processor.preProcessor && (t = e.processor.preProcessor(t, i, e.isFragment, e.processingContext)), t = this._EvaluatePreProcessors(t, n, e), e.processor.postProcessor && (t = e.processor.postProcessor(t, i, e.isFragment, e.processingContext, s)), s._features.needShaderCodeInlining && (t = s.inlineShaderCode(t)), t;
+  }
+  static _ApplyPreProcessing(r, e, s) {
+    var t, i;
+    let n = r;
+    const o = e.defines, c = this._PreparePreProcessors(e, s);
+    return !((t = e.processor) === null || t === void 0) && t.preProcessor && (n = e.processor.preProcessor(n, o, e.isFragment, e.processingContext)), n = this._EvaluatePreProcessors(n, c, e), !((i = e.processor) === null || i === void 0) && i.postProcessor && (n = e.processor.postProcessor(n, o, e.isFragment, e.processingContext, s)), s._features.needShaderCodeInlining && (n = s.inlineShaderCode(n)), n;
+  }
+  static _ProcessIncludes(r, e, s) {
+    _.length = 0;
+    let t;
+    for (; (t = R.exec(r)) !== null; )
+      _.push(t);
+    let i = String(r), n = [r], o = !1;
+    for (const c of _) {
+      let f = c[1];
+      if (f.indexOf("__decl__") !== -1 && (f = f.replace(A, ""), e.supportsUniformBuffers && (f = f.replace("Vertex", "Ubo").replace("Fragment", "Ubo")), f = f + "Declaration"), e.includesShadersStore[f]) {
+        let a = e.includesShadersStore[f];
+        if (c[2]) {
+          const d = c[3].split(",");
+          for (let l = 0; l < d.length; l += 2) {
+            const h = new RegExp(d[l], "g"), u = d[l + 1];
+            a = a.replace(h, u);
+          }
+        }
+        if (c[4]) {
+          const d = c[5];
+          if (d.indexOf("..") !== -1) {
+            const l = d.split(".."), h = parseInt(l[0]);
+            let u = parseInt(l[1]), x = a.slice(0);
+            a = "", isNaN(u) && (u = e.indexParameters[l[1]]);
+            for (let P = h; P < u; P++)
+              e.supportsUniformBuffers || (x = x.replace(E, (k, O) => O + "{X}")), a += x.replace(I, P.toString()) + `
+`;
+          } else
+            e.supportsUniformBuffers || (a = a.replace(E, (l, h) => h + "{X}")), a = a.replace(I, d);
+        }
+        const p = [];
+        for (const d of n) {
+          const l = d.split(c[0]);
+          for (let h = 0; h < l.length - 1; h++)
+            p.push(l[h]), p.push(a);
+          p.push(l[l.length - 1]);
+        }
+        n = p, o = o || a.indexOf("#include<") >= 0 || a.indexOf("#include <") >= 0;
+      } else {
+        const a = e.shadersRepository + "ShadersInclude/" + f + ".fx";
+        m._FileToolsLoadFile(a, (p) => {
+          e.includesShadersStore[f] = p, this._ProcessIncludes(n.join(""), e, s);
+        });
+        return;
+      }
+    }
+    _.length = 0, i = n.join(""), o ? this._ProcessIncludes(i.toString(), e, s) : s(i);
+  }
+  /**
+   * Loads a file from a url
+   * @param url url to load
+   * @param onSuccess callback called when the file successfully loads
+   * @param onProgress callback called while file is loading (if the server supports this mode)
+   * @param offlineProvider defines the offline provider for caching
+   * @param useArrayBuffer defines a boolean indicating that date must be returned as ArrayBuffer
+   * @param onError callback called when the file fails to load
+   * @returns a file request object
+   * @internal
+   */
+  static _FileToolsLoadFile(r, e, s, t, i, n) {
+    throw D("FileTools");
+  }
+}
+m._MoveCursorRegex = /(#ifdef)|(#else)|(#elif)|(#endif)|(#ifndef)|(#if)/;
+export {
+  m as ShaderProcessor
+};

package/dist/node_modules/@babylonjs/core/Engines/WebGL/webGL2ShaderProcessors.esm.js

@@ -0,0 +1,30 @@
+import { ShaderLanguage as n } from "../../Materials/shaderLanguage.esm.js";
+const i = /(flat\s)?\s*varying\s*.*/;
+class _ {
+  constructor() {
+    this.shaderLanguage = n.GLSL;
+  }
+  attributeProcessor(e) {
+    return e.replace("attribute", "in");
+  }
+  varyingCheck(e, r) {
+    return i.test(e);
+  }
+  varyingProcessor(e, r) {
+    return e.replace("varying", r ? "in" : "out");
+  }
+  postProcessor(e, r, t) {
+    const a = e.search(/#extension.+GL_EXT_draw_buffers.+require/) !== -1, s = /#extension.+(GL_OVR_multiview2|GL_OES_standard_derivatives|GL_EXT_shader_texture_lod|GL_EXT_frag_depth|GL_EXT_draw_buffers).+(enable|require)/g;
+    if (e = e.replace(s, ""), e = e.replace(/texture2D\s*\(/g, "texture("), t)
+      e = e.replace(/texture2DLodEXT\s*\(/g, "textureLod("), e = e.replace(/textureCubeLodEXT\s*\(/g, "textureLod("), e = e.replace(/textureCube\s*\(/g, "texture("), e = e.replace(/gl_FragDepthEXT/g, "gl_FragDepth"), e = e.replace(/gl_FragColor/g, "glFragColor"), e = e.replace(/gl_FragData/g, "glFragData"), e = e.replace(/void\s+?main\s*\(/g, (a ? "" : `layout(location = 0) out vec4 glFragColor;
+`) + "void main(");
+    else if (r.indexOf("#define MULTIVIEW") !== -1)
+      return `#extension GL_OVR_multiview2 : require
+layout (num_views = 2) in;
+` + e;
+    return e;
+  }
+}
+export {
+  _ as WebGL2ShaderProcessor
+};