@xifu/shader-graph-glsl 0.1.0

package/dist/runtime/index.js

@@ -0,0 +1,638 @@
+// src/runtime/RuntimeProgram.ts
+function compileShader(gl, source, type) {
+  const shader = gl.createShader(type);
+  gl.shaderSource(shader, source);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    const log = gl.getShaderInfoLog(shader);
+    const stage = type === gl.VERTEX_SHADER ? "VERTEX" : "FRAGMENT";
+    gl.deleteShader(shader);
+    throw new Error(`GLSL ${stage} compile error:
+${log}
+
+--- Source ---
+${source}`);
+  }
+  return shader;
+}
+function createProgram(gl, vertSrc, fragSrc) {
+  const vs = compileShader(gl, vertSrc, gl.VERTEX_SHADER);
+  const fs = compileShader(gl, fragSrc, gl.FRAGMENT_SHADER);
+  const program = gl.createProgram();
+  gl.attachShader(program, vs);
+  gl.attachShader(program, fs);
+  gl.linkProgram(program);
+  gl.deleteShader(vs);
+  gl.deleteShader(fs);
+  if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
+    const log = gl.getProgramInfoLog(program);
+    gl.deleteProgram(program);
+    throw new Error(`GLSL program link error:
+${log}`);
+  }
+  return program;
+}
+function createRuntimeProgram(gl, config) {
+  const program = createProgram(gl, config.vertCode, config.fragCode);
+  const uniforms = {};
+  const attribs = {};
+  for (const meta of config.uniforms) {
+    uniforms[meta.name] = gl.getUniformLocation(program, meta.name);
+  }
+  const numAttribs = gl.getProgramParameter(program, gl.ACTIVE_ATTRIBUTES);
+  for (let i = 0; i < numAttribs; i++) {
+    const info = gl.getActiveAttrib(program, i);
+    if (info) {
+      attribs[info.name] = gl.getAttribLocation(program, info.name);
+    }
+  }
+  return { program, uniforms, attribs, config, textureUnitMap: {} };
+}
+function applyUniforms(gl, program, values) {
+  const { uniforms, config } = program;
+  for (const meta of config.uniforms) {
+    const loc = uniforms[meta.name];
+    if (loc === void 0 || loc === null) continue;
+    const value = values[meta.name] ?? meta.default;
+    if (value === void 0 || value === null) continue;
+    applyUniformValue(gl, loc, meta.type, value);
+  }
+}
+function applyUniformValue(gl, loc, type, value) {
+  switch (type) {
+    case "float":
+      gl.uniform1f(loc, value);
+      break;
+    case "int":
+      gl.uniform1i(loc, value);
+      break;
+    case "bool":
+      gl.uniform1i(loc, value ? 1 : 0);
+      break;
+    case "vec2":
+      gl.uniform2fv(loc, value);
+      break;
+    case "vec3":
+      gl.uniform3fv(loc, value);
+      break;
+    case "vec4":
+      gl.uniform4fv(loc, value);
+      break;
+    case "mat2":
+      gl.uniformMatrix2fv(loc, false, value);
+      break;
+    case "mat3":
+      gl.uniformMatrix3fv(loc, false, value);
+      break;
+    case "mat4":
+      gl.uniformMatrix4fv(loc, false, value);
+      break;
+    case "sampler2D":
+      gl.uniform1i(loc, value);
+      break;
+  }
+}
+function destroyRuntimeProgram(gl, program) {
+  gl.deleteProgram(program.program);
+}
+
+// src/runtime/RuntimeRenderer.ts
+var RuntimeRenderer = class {
+  gl;
+  programs = /* @__PURE__ */ new Map();
+  currentProgram = null;
+  defaultVAO = null;
+  textureUnitCounter = 0;
+  textureCache = /* @__PURE__ */ new Map();
+  canvas;
+  clearColor = [0, 0, 0, 0];
+  viewport = [0, 0, 0, 0];
+  scissor = [0, 0, 0, 0];
+  constructor(canvas, options) {
+    this.canvas = canvas;
+    const gl = canvas.getContext("webgl2", {
+      alpha: true,
+      antialias: true,
+      premultipliedAlpha: false,
+      ...options
+    });
+    if (!gl) throw new Error("WebGL2 not supported");
+    this.gl = gl;
+    this.defaultVAO = gl.createVertexArray();
+    gl.enable(gl.DEPTH_TEST);
+    gl.depthFunc(gl.LEQUAL);
+    this.viewport = [0, 0, canvas.width, canvas.height];
+    this.scissor = [0, 0, canvas.width, canvas.height];
+  }
+  // ============================================================
+  // 着色器程序管理
+  // ============================================================
+  /** 从 ShaderConfig 加载程序 */
+  loadProgram(config, key) {
+    const cacheKey = key || config.id;
+    const existing = this.programs.get(cacheKey);
+    if (existing) return existing;
+    const program = createRuntimeProgram(this.gl, config);
+    this.programs.set(cacheKey, program);
+    return program;
+  }
+  /** 获取已缓存的程序 */
+  getProgram(key) {
+    return this.programs.get(key);
+  }
+  // ============================================================
+  // 纹理管理
+  // ============================================================
+  /** 加载纹理 (支持 URL 或 HTMLImageElement) */
+  loadTexture(url) {
+    const cached = this.textureCache.get(url);
+    if (cached) return Promise.resolve(cached);
+    return new Promise((resolve, reject) => {
+      const img = new Image();
+      img.crossOrigin = "anonymous";
+      img.onload = () => {
+        const gl = this.gl;
+        const texture = gl.createTexture();
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, img);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
+        gl.generateMipmap(gl.TEXTURE_2D);
+        gl.bindTexture(gl.TEXTURE_2D, null);
+        this.textureCache.set(url, texture);
+        resolve(texture);
+      };
+      img.onerror = () => reject(new Error(`Failed to load texture: ${url}`));
+      img.src = url;
+    });
+  }
+  /** 绑定纹理到 uniform */
+  bindTexture(uniformName, texture, unit) {
+    const gl = this.gl;
+    gl.activeTexture(gl.TEXTURE0 + unit);
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+    gl.uniform1i(this.gl.getUniformLocation(this.currentProgram.program, uniformName), unit);
+  }
+  // ============================================================
+  // 几何体管理
+  // ============================================================
+  /** 创建几何体 VAO */
+  createGeometry(geo) {
+    const gl = this.gl;
+    const vao = gl.createVertexArray();
+    gl.bindVertexArray(vao);
+    for (const [name, attr] of Object.entries(geo.attributes)) {
+      const buffer = gl.createBuffer();
+      gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+      gl.bufferData(gl.ARRAY_BUFFER, attr.data, gl.STATIC_DRAW);
+      const loc = parseInt(name.replace(/\D/g, ""), 10);
+      if (!isNaN(loc)) {
+        gl.enableVertexAttribArray(loc);
+        gl.vertexAttribPointer(loc, attr.size, gl.FLOAT, attr.normalized || false, attr.stride || 0, attr.offset || 0);
+      }
+    }
+    if (geo.index) {
+      const buffer = gl.createBuffer();
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, buffer);
+      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, geo.index, gl.STATIC_DRAW);
+    }
+    gl.bindVertexArray(null);
+    return vao;
+  }
+  // ============================================================
+  // 渲染
+  // ============================================================
+  /** 清屏 */
+  clear() {
+    const gl = this.gl;
+    const [r, g, b, a] = this.clearColor;
+    gl.clearColor(r, g, b, a);
+    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+  }
+  /** 渲染单次绘制调用 */
+  drawMesh(mesh) {
+    const gl = this.gl;
+    const { program, geometry, uniforms, mode } = mesh;
+    if (this.currentProgram !== program) {
+      gl.useProgram(program.program);
+      this.currentProgram = program;
+    }
+    applyUniforms(gl, program, uniforms);
+    const vao = this.createGeometry(geometry);
+    gl.bindVertexArray(vao);
+    if (geometry.index) {
+      const indexType = geometry.index instanceof Uint32Array ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+      gl.drawElements(mode || gl.TRIANGLES, geometry.index.length, indexType, 0);
+    } else {
+      gl.drawArrays(mode || gl.TRIANGLES, 0, geometry.vertexCount);
+    }
+    gl.bindVertexArray(null);
+  }
+  /** 调整大小 */
+  resize(width, height) {
+    this.canvas.width = width;
+    this.canvas.height = height;
+    this.viewport = [0, 0, width, height];
+    this.scissor = [0, 0, width, height];
+    this.gl.viewport(0, 0, width, height);
+  }
+  /** 销毁 */
+  dispose() {
+    for (const program of this.programs.values()) {
+      destroyRuntimeProgram(this.gl, program);
+    }
+    this.programs.clear();
+    for (const texture of this.textureCache.values()) {
+      this.gl.deleteTexture(texture);
+    }
+    this.textureCache.clear();
+    this.gl.bindVertexArray(null);
+    if (this.defaultVAO) {
+      this.gl.deleteVertexArray(this.defaultVAO);
+    }
+  }
+};
+
+// packages/runtime/src/ShaderGraphRuntime.ts
+var ShaderGraphRuntime = class {
+  /** 底层渲染器 */
+  renderer;
+  /** WebGL 上下文 */
+  gl;
+  /** 画布 */
+  canvas;
+  /** 子图关联表: programKey → { subGraphId → ShaderConfig } */
+  subGraphLinks = /* @__PURE__ */ new Map();
+  animFrameId = null;
+  lastTime = 0;
+  frameCallback = null;
+  _isPlaying = false;
+  /**
+   * 构造运行时
+   *
+   * @param canvas  - HTMLCanvasElement
+   * @param options - 运行时选项
+   */
+  constructor(canvas, options) {
+    this.renderer = new RuntimeRenderer(canvas, options?.contextAttributes);
+    this.gl = this.renderer.gl;
+    this.canvas = canvas;
+    if (options?.clearColor) {
+      this.renderer.clearColor = options.clearColor;
+    }
+  }
+  // ============================================================
+  // 着色器管理
+  // ============================================================
+  /**
+   * 加载着色器配置
+   *
+   * @param config - 由编辑器编译产出的 ShaderConfig
+   * @param key    - 缓存键 (默认使用 config.id)
+   * @returns 程序句柄
+   *
+   * @example
+   * ```ts
+   * const program = runtime.load(shaderConfig);
+   * ```
+   */
+  load(config, key) {
+    return this.renderer.loadProgram(config, key);
+  }
+  /**
+   * 获取已缓存的程序
+   *
+   * @param key - 缓存键
+   */
+  get(key) {
+    return this.renderer.getProgram(key);
+  }
+  /**
+   * 卸载着色器程序
+   *
+   * @param handle - 程序句柄
+   */
+  unload(handle) {
+    this.gl.deleteProgram(handle.program);
+    this.subGraphLinks.delete(handle.config.id);
+  }
+  // ============================================================
+  // 子图关联
+  // ============================================================
+  /**
+   * 关联子图配置到主程序
+   *
+   * 子图在编译时已内联到主图的 vertCode/fragCode 中。
+   * 此方法将子图的 uniform 元数据注册到主程序，使运行时
+   * 能正确管理所有由子图引入的 uniform 变量。
+   *
+   * @param program    - 主程序句柄 (由 load() 返回)
+   * @param subGraphId - 子图 ID (与主图 SubGraph 节点的 asset.id 对应)
+   * @param config     - 子图的 ShaderConfig
+   *
+   * @example
+   * ```ts
+   * const mainProg = runtime.load(mainConfig);
+   * runtime.linkSubGraph(mainProg, 'flowMap', flowMapSubConfig);
+   * ```
+   */
+  linkSubGraph(program, subGraphId, config) {
+    const key = program.config.id;
+    let links = this.subGraphLinks.get(key);
+    if (!links) {
+      links = /* @__PURE__ */ new Map();
+      this.subGraphLinks.set(key, links);
+    }
+    links.set(subGraphId, config);
+    if (config.uniforms && program.config.uniforms) {
+      const existingNames = new Set(program.config.uniforms.map((u) => u.name));
+      for (const u of config.uniforms) {
+        if (!existingNames.has(u.name)) {
+          program.config.uniforms.push(u);
+        }
+      }
+    }
+  }
+  /**
+   * 批量关联子图
+   *
+   * @param program   - 主程序句柄
+   * @param subGraphs - { [subGraphId]: ShaderConfig }
+   */
+  linkSubGraphs(program, subGraphs) {
+    for (const [id, config] of Object.entries(subGraphs)) {
+      this.linkSubGraph(program, id, config);
+    }
+  }
+  /**
+   * 加载主图并同时关联其子图
+   *
+   * 等价于依次调用 load() + linkSubGraphs()。
+   *
+   * @param config     - 主图 ShaderConfig
+   * @param subGraphs  - 子图配置表 { subGraphId: ShaderConfig }
+   * @param key        - 缓存键 (可选)
+   * @returns 主程序句柄
+   *
+   * @example
+   * ```ts
+   * const program = runtime.loadWithSubGraphs(mainConfig, {
+   *   'flowMap': flowMapSubConfig,
+   *   'noise': noiseSubConfig,
+   * });
+   * ```
+   */
+  loadWithSubGraphs(config, subGraphs, key) {
+    const program = this.load(config, key);
+    this.linkSubGraphs(program, subGraphs);
+    return program;
+  }
+  /**
+   * 获取程序关联的子图列表
+   *
+   * @param program - 程序句柄
+   * @returns 子图 ID 列表
+   */
+  getLinkedSubGraphs(program) {
+    const links = this.subGraphLinks.get(program.config.id);
+    return links ? Array.from(links.keys()) : [];
+  }
+  /**
+   * 获取程序关联的子图配置
+   *
+   * @param program    - 程序句柄
+   * @param subGraphId - 子图 ID
+   * @returns ShaderConfig 或 undefined
+   */
+  getSubGraphConfig(program, subGraphId) {
+    return this.subGraphLinks.get(program.config.id)?.get(subGraphId);
+  }
+  // ============================================================
+  // Uniform 控制
+  // ============================================================
+  /**
+   * 获取 Uniform 绑定器
+   *
+   * 提供链式 API 方便批量设置 uniform。
+   *
+   * @param handle - 程序句柄
+   * @returns UniformBinder
+   *
+   * @example
+   * ```ts
+   * runtime.uniforms(program)
+   *   .set('uColor', [1, 0, 0, 1])
+   *   .set('uTime', 0.5)
+   *   .texture('uMainTex', img)
+   *   .commit();
+   * ```
+   */
+  uniforms(handle) {
+    const gl = this.gl;
+    const deferred = [];
+    const binder = {
+      set(name, value) {
+        deferred.push(() => {
+          const loc = handle.uniforms[name];
+          if (!loc) return;
+          const arr = Array.isArray(value) ? value : [value];
+          switch (arr.length) {
+            case 1:
+              gl.uniform1f(loc, arr[0]);
+              break;
+            case 2:
+              gl.uniform2f(loc, arr[0], arr[1]);
+              break;
+            case 3:
+              gl.uniform3f(loc, arr[0], arr[1], arr[2]);
+              break;
+            case 4:
+              gl.uniform4f(loc, arr[0], arr[1], arr[2], arr[3]);
+              break;
+            default:
+              ;
+          }
+        });
+        return binder;
+      },
+      setMany(values) {
+        for (const [k, v] of Object.entries(values)) {
+          if (v == null) continue;
+          deferred.push(() => {
+            const loc = handle.uniforms[k];
+            if (!loc) return;
+            const arr = Array.isArray(v) ? v : [v];
+            switch (arr.length) {
+              case 1:
+                gl.uniform1f(loc, arr[0]);
+                break;
+              case 2:
+                gl.uniform2f(loc, arr[0], arr[1]);
+                break;
+              case 3:
+                gl.uniform3f(loc, arr[0], arr[1], arr[2]);
+                break;
+              case 4:
+                gl.uniform4f(loc, arr[0], arr[1], arr[2], arr[3]);
+                break;
+            }
+          });
+        }
+        return binder;
+      },
+      texture(_name, _source, _unit) {
+        return binder;
+      },
+      commit() {
+        gl.useProgram(handle.program);
+        for (const fn of deferred) fn();
+        deferred.length = 0;
+      }
+    };
+    return binder;
+  }
+  // ============================================================
+  // 渲染
+  // ============================================================
+  /**
+   * 清除缓冲区
+   *
+   * 先应用设置的清除颜色，再清除缓冲区。
+   *
+   * @param mask - 清除掩码 (默认 gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT)
+   */
+  clear(mask) {
+    const gl = this.gl;
+    const cc = this.renderer.clearColor;
+    gl.clearColor(cc[0], cc[1], cc[2], cc[3]);
+    const m = mask ?? gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT;
+    gl.clear(m);
+  }
+  /**
+   * 设置清除颜色
+   */
+  setClearColor(r, g, b, a) {
+    this.renderer.clearColor = [r, g, b, a];
+  }
+  /**
+   * 绘制网格
+   *
+   * @param mesh - 网格渲染描述
+   *
+   * @example
+   * ```ts
+   * runtime.draw({
+   *   geometry: { attributes: { aPosition: { data, size: 3 } }, vertexCount: 3 },
+   *   program: myProgram,
+   *   uniforms: { uColor: [1, 0, 0, 1] },
+   * });
+   * ```
+   */
+  draw(mesh) {
+    const { geometry, program, uniforms, mode } = mesh;
+    this.uniforms(program).setMany(uniforms || {}).commit();
+    const gl = this.gl;
+    gl.useProgram(program.program);
+    const vao = gl.createVertexArray();
+    gl.bindVertexArray(vao);
+    for (const [name, attrib] of Object.entries(geometry.attributes)) {
+      const loc = program.attribs[name];
+      if (loc === void 0) continue;
+      const buffer = gl.createBuffer();
+      gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
+      gl.bufferData(gl.ARRAY_BUFFER, attrib.data, gl.STATIC_DRAW);
+      gl.enableVertexAttribArray(loc);
+      gl.vertexAttribPointer(loc, attrib.size, gl.FLOAT, attrib.normalized ?? false, attrib.stride ?? 0, attrib.offset ?? 0);
+    }
+    if (geometry.index) {
+      const idxBuffer = gl.createBuffer();
+      gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, idxBuffer);
+      gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, geometry.index, gl.STATIC_DRAW);
+      const idxType = geometry.index instanceof Uint32Array ? gl.UNSIGNED_INT : gl.UNSIGNED_SHORT;
+      gl.drawElements(mode ?? gl.TRIANGLES, geometry.index.length, idxType, 0);
+    } else {
+      gl.drawArrays(mode ?? gl.TRIANGLES, 0, geometry.vertexCount);
+    }
+    gl.bindVertexArray(null);
+    gl.deleteVertexArray(vao);
+  }
+  // ============================================================
+  // 动画循环
+  // ============================================================
+  /**
+   * 开始动画循环
+   *
+   * @param callback - 每帧回调 (time, delta)
+   *
+   * @example
+   * ```ts
+   * runtime.play((time, delta) => {
+   *   runtime.uniforms(program).set('uTime', time).commit();
+   *   runtime.draw(mesh);
+   * });
+   * ```
+   */
+  play(callback) {
+    if (this._isPlaying) return;
+    this._isPlaying = true;
+    this.lastTime = performance.now();
+    this.frameCallback = callback ?? null;
+    const tick = (now) => {
+      if (!this._isPlaying) return;
+      const delta = (now - this.lastTime) / 1e3;
+      this.lastTime = now;
+      this.clear();
+      this.frameCallback?.(now / 1e3, delta);
+      this.animFrameId = requestAnimationFrame(tick);
+    };
+    this.animFrameId = requestAnimationFrame(tick);
+  }
+  /** 是否正在播放动画 */
+  get isPlaying() {
+    return this._isPlaying;
+  }
+  /**
+   * 停止动画循环
+   */
+  stop() {
+    this._isPlaying = false;
+    if (this.animFrameId !== null) {
+      cancelAnimationFrame(this.animFrameId);
+      this.animFrameId = null;
+    }
+    this.frameCallback = null;
+  }
+  // ============================================================
+  // 尺寸调整
+  // ============================================================
+  /**
+   * 调整画布尺寸 (自动同步 viewport)
+   *
+   * @param width  - 像素宽度
+   * @param height - 像素高度
+   */
+  resize(width, height) {
+    this.canvas.width = width;
+    this.canvas.height = height;
+    this.renderer.viewport = [0, 0, width, height];
+    this.gl.viewport(0, 0, width, height);
+  }
+  // ============================================================
+  // 资源清理
+  // ============================================================
+  /**
+   * 释放所有资源
+   *
+   * 清理着色器程序、纹理、停止动画。
+   * 调用后不可再使用此实例。
+   */
+  dispose() {
+    this.stop();
+    const gl = this.gl;
+  }
+};
+export {
+  ShaderGraphRuntime
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@xifu/shader-graph-glsl",
+  "version": "0.1.0",
+  "description": "Shader Graph GLSL — visual node-based shader editor & runtime engine",
+  "type": "module",
+  "private": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    "./runtime": {
+      "types": "./dist/runtime/index.d.ts",
+      "import": "./dist/runtime/index.js"
+    },
+    "./editor": {
+      "types": "./dist/editor/index.d.ts",
+      "import": "./dist/editor/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "vite",
+    "dev:docs": "pnpm --filter @xifu/shader-graph-glsl-docs dev",
+    "build": "tsc && vite build",
+    "build:npm": "tsup",
+    "build:editor": "vite build --config vite.config.editor.ts && pnpm -s exec node -e \"require('fs').renameSync('apps/docs/public/editor/editor.html','apps/docs/public/editor/index.html')\"",
+    "build:docs": "pnpm build:editor && pnpm --filter @xifu/shader-graph-glsl-docs build",
+    "preview": "vite preview",
+    "preview:docs": "pnpm --filter @xifu/shader-graph-glsl-docs preview",
+    "prepublishOnly": "pnpm build:npm"
+  },
+  "keywords": [
+    "node material",
+    "shader graph",
+    "glsl",
+    "webgl2",
+    "node-editor",
+    "visual-programming"
+  ],
+  "author": "928200728@qq.com",
+  "license": "MIT",
+  "dependencies": {
+    "copy-to-clipboard": "3.3.3",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "rete-area-plugin": "^0.2.1",
+    "three": "^0.151.3",
+    "use-debounce": "^9.0.4"
+  },
+  "devDependencies": {
+    "@types/react": "^18",
+    "@types/react-dom": "^18",
+    "@types/three": "^0.150.2",
+    "@vitejs/plugin-react": "^3.1.0",
+    "less": "^4.1.3",
+    "tsup": "^8.5.1",
+    "typescript": "^4.9.3",
+    "vite": "^4.5.2"
+  },
+  "peerDependencies": {
+    "monaco-editor": "^0.45.0"
+  },
+  "peerDependenciesMeta": {
+    "monaco-editor": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}