@holoscript/core 6.0.4 → 7.0.0

package/dist/chunk-TSH3MSQU.cjs

@@ -1,129 +0,0 @@
-'use strict';
-
-var chunkILRBGFVD_cjs = require('./chunk-ILRBGFVD.cjs');
-var orbital = require('@holoscript/engine/orbital');
-
-// src/traits/MitosisTrait.ts
-var mitosisHandler = {
-  name: "mitosis",
-  defaultConfig: {
-    strategy: "collaborative",
-    max_children: 5,
-    auto_cleanup: true
-  },
-  onAttach(node, config, context) {
-    const state = {
-      parent_id: ("parent_id" in config ? config.parent_id : null) || null,
-      active_children: [],
-      tasks_delegated: 0,
-      completed_tasks: 0,
-      last_sync_time: Date.now()
-    };
-    node.__mitosisState = state;
-    context.emit?.("mitosis_init", {
-      nodeId: node.id,
-      strategy: config.strategy,
-      parent_id: state.parent_id
-    });
-  },
-  onDetach(node, config, context) {
-    const state = node.__mitosisState;
-    if (state && config.auto_cleanup) {
-      for (const childId of state.active_children) {
-        context.emit?.("mitosis_despawn_child", { childId });
-      }
-    }
-    delete node.__mitosisState;
-  },
-  onEvent(node, config, context, event) {
-    const state = node.__mitosisState;
-    if (!state) return;
-    if (event.type === "mitosis_spawned") {
-      const childId = event.childId;
-      const parentId = event.parentId;
-      if (node.id === parentId) {
-        state.active_children.push(childId);
-        state.tasks_delegated++;
-        context.emit?.("on_mitosis_spawned", { childId, parentId: node.id });
-      }
-    } else if (event.type === "mitosis_child_complete") {
-      const childId = "childId" in event ? event.childId : "";
-      const parentId = "parentId" in event ? event.parentId : "";
-      const result = "result" in event ? event.result : void 0;
-      if (node.id === parentId) {
-        state.completed_tasks++;
-        state.last_sync_time = Date.now();
-        context.emit?.("mitosis_synced", {
-          parentId: node.id,
-          childId,
-          result
-        });
-        if (config.strategy === "collaborative") {
-          if (result && typeof result === "object") {
-            Object.assign(node.properties || {}, result);
-          }
-        }
-      }
-    } else if (event.type === "mitosis_child_failed") {
-      context.emit?.("on_mitosis_error", {
-        parentId: node.id,
-        childId: event.childId,
-        error: event.error
-      });
-    }
-  }
-};
-var orbitalHandler = {
-  name: "orbital",
-  defaultConfig: {},
-  /**
-   * Called when trait is attached to a node
-   */
-  onAttach(node, _config, _context) {
-    chunkILRBGFVD_cjs.logger.info(`[OrbitalTrait] Attached to ${node.name}`);
-  },
-  /**
-   * Called every frame to update orbital position
-   */
-  onUpdate(node, config, context, _delta) {
-    const properties = node.properties || {};
-    const mergedConfig = { ...properties, ...config };
-    if (!mergedConfig || !mergedConfig.semiMajorAxis) {
-      return;
-    }
-    const julianDate = context.julianDate || 0;
-    const visualScale = context.getScaleMultiplier() * 50;
-    const satelliteScale = 5;
-    const rawPosition = orbital.calculatePosition(mergedConfig, julianDate);
-    const currentScale = mergedConfig.parent ? visualScale * satelliteScale : visualScale;
-    let finalPosition = {
-      x: rawPosition.x * currentScale,
-      y: rawPosition.z * currentScale,
-      z: rawPosition.y * currentScale
-    };
-    if (mergedConfig.parent) {
-      let parentNode = context.getNode?.(mergedConfig.parent);
-      if (!parentNode && typeof mergedConfig.parent === "object" && mergedConfig.parent && mergedConfig.parent.position) {
-        parentNode = mergedConfig.parent;
-      }
-      if (parentNode && parentNode.position) {
-        finalPosition = {
-          x: finalPosition.x + (parentNode.position.x || 0),
-          y: finalPosition.y + (parentNode.position.y || 0),
-          z: finalPosition.z + (parentNode.position.z || 0)
-        };
-      } else {
-        if (typeof mergedConfig.parent === "string") {
-          chunkILRBGFVD_cjs.logger.warn(`[OrbitalTrait] Parent "${mergedConfig.parent}" not found for ${node.name}`);
-        }
-      }
-    }
-    node.position = finalPosition;
-    context.emit("position_update", { position: finalPosition });
-  }
-};
-
-exports.mitosisHandler = mitosisHandler;
-exports.orbitalHandler = orbitalHandler;
-//# sourceMappingURL=chunk-TSH3MSQU.cjs.map
-//# sourceMappingURL=chunk-TSH3MSQU.cjs.map

package/dist/chunk-UERJ3YJV.js

@@ -1,504 +0,0 @@
-import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, compilePhysicsBlock, physicsToSDF, compileMaterialBlock, materialToSDF } from './chunk-YQK5JNFK.js';
-import { init_CompilerBase, CompilerBase } from './chunk-6XSERL6L.js';
-import { __export, __esm } from './chunk-2CWOLHTE.js';
-import { ANSCapabilityPath } from '@holoscript/platform';
-
-// src/compiler/SDFCompiler.ts
-var SDFCompiler_exports = {};
-__export(SDFCompiler_exports, {
-  SDFCompiler: () => SDFCompiler,
-  default: () => SDFCompiler_default
-});
-var SDFCompiler, SDFCompiler_default;
-var init_SDFCompiler = __esm({
-  "src/compiler/SDFCompiler.ts"() {
-    init_CompilerBase();
-    init_DomainBlockCompilerMixin();
-    SDFCompiler = class extends CompilerBase {
-      constructor(options = {}) {
-        super();
-        this.compilerName = "SDFCompiler";
-        this.lines = [];
-        this.indentLevel = 0;
-        this.options = {
-          worldName: options.worldName || "holoscript_world",
-          sdfVersion: options.sdfVersion || "1.8",
-          includePhysics: options.includePhysics ?? true,
-          physicsEngine: options.physicsEngine || "ode",
-          realTimeFactor: options.realTimeFactor ?? 1,
-          includeScene: options.includeScene ?? true,
-          meshPathPrefix: options.meshPathPrefix || "model://"
-        };
-      }
-      getRequiredCapability() {
-        return ANSCapabilityPath.SDF;
-      }
-      compile(composition, agentToken, outputPath) {
-        this.validateCompilerAccess(agentToken, outputPath);
-        this.lines = [];
-        this.indentLevel = 0;
-        this.emit('<?xml version="1.0"?>');
-        this.emit(`<!-- Auto-generated by HoloScript SDFCompiler -->`);
-        this.emit(
-          `<!-- Source: composition "${this.escapeStringValue(composition.name, "TypeScript")}" -->`
-        );
-        this.emit("");
-        this.emit(`<sdf version="${this.options.sdfVersion}">`);
-        this.indentLevel++;
-        this.emit(`<world name="${this.escapeXml(this.options.worldName)}">`);
-        this.indentLevel++;
-        if (this.options.includePhysics) {
-          this.emitPhysics();
-        }
-        if (this.options.includeScene) {
-          this.emitScene(composition.environment);
-        }
-        this.emitGroundPlane();
-        this.emitSunLight();
-        if (composition.lights) {
-          for (const light of composition.lights) {
-            this.emitLight(light);
-          }
-        }
-        if (composition.objects) {
-          for (const obj of composition.objects) {
-            this.emitModel(obj);
-          }
-        }
-        if (composition.spatialGroups) {
-          for (const group of composition.spatialGroups) {
-            this.emitSpatialGroup(group);
-          }
-        }
-        this.emitSDFDomainBlocks(composition);
-        this.indentLevel--;
-        this.emit("</world>");
-        this.indentLevel--;
-        this.emit("</sdf>");
-        return this.lines.join("\n");
-      }
-      emitSDFDomainBlocks(composition) {
-        const domainBlocks = composition.domainBlocks ?? [];
-        if (domainBlocks.length === 0) return;
-        this.emit("");
-        this.emit("<!-- v4.2 Domain Blocks -->");
-        const compiled = compileDomainBlocks(
-          domainBlocks,
-          {
-            material: (block) => {
-              const mat = compileMaterialBlock(block);
-              return materialToSDF(mat);
-            },
-            physics: (block) => {
-              const phys = compilePhysicsBlock(block);
-              return physicsToSDF(phys);
-            },
-            audio: (block) => {
-              const audio = compileAudioSourceBlock(block);
-              return `<!-- Audio: ${this.escapeStringValue(audio.name, "TypeScript")} (${audio.keyword}) clip="${audio.properties.clip || ""}" -->`;
-            },
-            weather: (block) => {
-              const weather = compileWeatherBlock(block);
-              const layers = weather.layers.map((l) => `<!-- ${l.type}: ${JSON.stringify(l.properties)} -->`).join("\n");
-              return `<!-- Weather: ${weather.keyword} "${weather.name || ""}" -->
-${layers}`;
-            }
-          },
-          (block) => `<!-- Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "TypeScript")}" -->`
-        );
-        for (const output of compiled) {
-          for (const line of output.split("\n")) {
-            this.emit(line);
-          }
-        }
-      }
-      // ===== Property extraction helpers =====
-      getEnvProp(env, key) {
-        if (!env) return void 0;
-        if (Array.isArray(env.properties)) {
-          const prop = env.properties.find((p) => p.key === key);
-          return prop?.value;
-        } else {
-          return env[key];
-        }
-      }
-      getLightProp(light, key, fallback) {
-        if (Array.isArray(light.properties)) {
-          const prop = light.properties.find((p) => p.key === key);
-          return prop?.value ?? fallback;
-        } else if (light[key] !== void 0) {
-          return light[key];
-        }
-        return fallback;
-      }
-      getTraitName(trait) {
-        return typeof trait === "string" ? trait : trait.name;
-      }
-      hasTrait(obj, traitName) {
-        return obj.traits?.some((t) => this.getTraitName(t) === traitName) ?? false;
-      }
-      emitPhysics() {
-        this.emit(`<physics name="default_physics" type="${this.options.physicsEngine}">`);
-        this.indentLevel++;
-        this.emit("<max_step_size>0.001</max_step_size>");
-        this.emit(`<real_time_factor>${this.options.realTimeFactor}</real_time_factor>`);
-        this.emit("<real_time_update_rate>1000</real_time_update_rate>");
-        if (this.options.physicsEngine === "ode") {
-          this.emit("<ode>");
-          this.indentLevel++;
-          this.emit("<solver>");
-          this.indentLevel++;
-          this.emit("<type>quick</type>");
-          this.emit("<iters>50</iters>");
-          this.emit("<sor>1.3</sor>");
-          this.indentLevel--;
-          this.emit("</solver>");
-          this.emit("<constraints>");
-          this.indentLevel++;
-          this.emit("<cfm>0</cfm>");
-          this.emit("<erp>0.2</erp>");
-          this.indentLevel--;
-          this.emit("</constraints>");
-          this.indentLevel--;
-          this.emit("</ode>");
-        }
-        this.indentLevel--;
-        this.emit("</physics>");
-        this.emit("");
-      }
-      emitScene(environment) {
-        this.emit("<scene>");
-        this.indentLevel++;
-        const ambientLevel = this.getEnvProp(environment, "ambient_light") ?? 0.4;
-        this.emit(`<ambient>${ambientLevel} ${ambientLevel} ${ambientLevel} 1</ambient>`);
-        const skybox = this.getEnvProp(environment, "skybox");
-        if (skybox) {
-          const skyColors = {
-            sunset: "0.9 0.5 0.3 1",
-            night: "0.05 0.05 0.1 1",
-            nebula: "0.1 0.05 0.2 1",
-            day: "0.3 0.5 0.9 1",
-            overcast: "0.5 0.5 0.5 1"
-          };
-          this.emit(`<background>${skyColors[skybox] || "0.7 0.7 0.7 1"}</background>`);
-        } else {
-          this.emit("<background>0.7 0.7 0.7 1</background>");
-        }
-        this.emit("<shadows>true</shadows>");
-        this.indentLevel--;
-        this.emit("</scene>");
-        this.emit("");
-      }
-      emitGroundPlane() {
-        this.emit('<model name="ground_plane">');
-        this.indentLevel++;
-        this.emit("<static>true</static>");
-        this.emit('<link name="link">');
-        this.indentLevel++;
-        this.emit('<collision name="collision">');
-        this.indentLevel++;
-        this.emit("<geometry>");
-        this.indentLevel++;
-        this.emit("<plane>");
-        this.indentLevel++;
-        this.emit("<normal>0 0 1</normal>");
-        this.emit("<size>100 100</size>");
-        this.indentLevel--;
-        this.emit("</plane>");
-        this.indentLevel--;
-        this.emit("</geometry>");
-        this.indentLevel--;
-        this.emit("</collision>");
-        this.emit('<visual name="visual">');
-        this.indentLevel++;
-        this.emit("<geometry>");
-        this.indentLevel++;
-        this.emit("<plane>");
-        this.indentLevel++;
-        this.emit("<normal>0 0 1</normal>");
-        this.emit("<size>100 100</size>");
-        this.indentLevel--;
-        this.emit("</plane>");
-        this.indentLevel--;
-        this.emit("</geometry>");
-        this.emit("<material>");
-        this.indentLevel++;
-        this.emit("<ambient>0.8 0.8 0.8 1</ambient>");
-        this.emit("<diffuse>0.8 0.8 0.8 1</diffuse>");
-        this.indentLevel--;
-        this.emit("</material>");
-        this.indentLevel--;
-        this.emit("</visual>");
-        this.indentLevel--;
-        this.emit("</link>");
-        this.indentLevel--;
-        this.emit("</model>");
-        this.emit("");
-      }
-      emitSunLight() {
-        this.emit('<light name="sun" type="directional">');
-        this.indentLevel++;
-        this.emit("<cast_shadows>true</cast_shadows>");
-        this.emit("<pose>0 0 10 0 0 0</pose>");
-        this.emit("<diffuse>0.8 0.8 0.8 1</diffuse>");
-        this.emit("<specular>0.2 0.2 0.2 1</specular>");
-        this.emit("<direction>-0.5 0.1 -0.9</direction>");
-        this.indentLevel--;
-        this.emit("</light>");
-        this.emit("");
-      }
-      emitLight(light) {
-        const name = this.sanitizeName(light.name || "light");
-        const lightTypeValue = light.lightType || (typeof light.type === "string" && ["point", "directional", "spot", "hemisphere", "ambient", "area"].includes(
-          light.type
-        ) ? light.type : void 0);
-        const type = this.mapLightType(lightTypeValue);
-        this.emit(`<light name="${name}" type="${type}">`);
-        this.indentLevel++;
-        let castShadow = this.getLightProp(light, "cast_shadow", void 0);
-        if (castShadow === void 0) {
-          castShadow = this.getLightProp(light, "castShadow", true);
-        }
-        this.emit(`<cast_shadows>${castShadow}</cast_shadows>`);
-        const pos = this.getLightProp(light, "position", [0, 0, 5]);
-        this.emit(`<pose>${pos[0]} ${pos[1]} ${pos[2]} 0 0 0</pose>`);
-        const colorVal = this.getLightProp(light, "color", "#ffffff");
-        const color = this.parseColor(typeof colorVal === "string" ? colorVal : "#ffffff");
-        const intensity = this.getLightProp(light, "intensity", 1);
-        this.emit(
-          `<diffuse>${color.r * intensity} ${color.g * intensity} ${color.b * intensity} 1</diffuse>`
-        );
-        this.emit(`<specular>${color.r * 0.3} ${color.g * 0.3} ${color.b * 0.3} 1</specular>`);
-        if (type === "spot") {
-          const angle = this.getLightProp(light, "angle", 45);
-          this.emit("<spot>");
-          this.indentLevel++;
-          this.emit(`<inner_angle>${angle * 0.8 * Math.PI / 180}</inner_angle>`);
-          this.emit(`<outer_angle>${angle * Math.PI / 180}</outer_angle>`);
-          this.emit("<falloff>1</falloff>");
-          this.indentLevel--;
-          this.emit("</spot>");
-        }
-        const range = this.getLightProp(light, "range", 0);
-        if (range > 0) {
-          this.emit("<attenuation>");
-          this.indentLevel++;
-          this.emit(`<range>${range}</range>`);
-          this.emit("<constant>0.5</constant>");
-          this.emit("<linear>0.01</linear>");
-          this.emit("<quadratic>0.001</quadratic>");
-          this.indentLevel--;
-          this.emit("</attenuation>");
-        }
-        this.indentLevel--;
-        this.emit("</light>");
-        this.emit("");
-      }
-      emitModel(obj) {
-        const name = this.sanitizeName(obj.name);
-        const isStatic = !this.hasTrait(obj, "physics") && !this.hasTrait(obj, "rigid");
-        this.emit(`<model name="${name}">`);
-        this.indentLevel++;
-        if (isStatic) {
-          this.emit("<static>true</static>");
-        }
-        const pos = this.extractPosition(obj);
-        const rot = this.extractRotation(obj);
-        this.emit(`<pose>${pos[0]} ${pos[1]} ${pos[2]} ${rot[0]} ${rot[1]} ${rot[2]}</pose>`);
-        this.emit(`<link name="${name}_link">`);
-        this.indentLevel++;
-        if (!isStatic) {
-          const mass = this.extractMass(obj) || 1;
-          this.emit("<inertial>");
-          this.indentLevel++;
-          this.emit(`<mass>${mass}</mass>`);
-          this.emit("<inertia>");
-          this.indentLevel++;
-          this.emit(`<ixx>${mass * 0.1}</ixx><ixy>0</ixy><ixz>0</ixz>`);
-          this.emit(`<iyy>${mass * 0.1}</iyy><iyz>0</iyz>`);
-          this.emit(`<izz>${mass * 0.1}</izz>`);
-          this.indentLevel--;
-          this.emit("</inertia>");
-          this.indentLevel--;
-          this.emit("</inertial>");
-        }
-        if (this.hasTrait(obj, "collidable") || this.hasTrait(obj, "physics") || this.hasTrait(obj, "rigid")) {
-          this.emit('<collision name="collision">');
-          this.indentLevel++;
-          this.emitGeometry(obj);
-          this.indentLevel--;
-          this.emit("</collision>");
-        }
-        this.emit('<visual name="visual">');
-        this.indentLevel++;
-        this.emitGeometry(obj);
-        this.emitMaterial(obj);
-        this.indentLevel--;
-        this.emit("</visual>");
-        this.indentLevel--;
-        this.emit("</link>");
-        this.indentLevel--;
-        this.emit("</model>");
-        this.emit("");
-      }
-      emitSpatialGroup(group) {
-        this.emit(
-          `<!-- Spatial Group: ${this.escapeStringValue(group.name, "TypeScript")} -->`
-        );
-        if (group.objects) {
-          for (const obj of group.objects) {
-            this.emitModel(obj);
-          }
-        }
-      }
-      emitGeometry(obj) {
-        const geometryProp = obj.properties.find((p) => p.key === "geometry");
-        const geometryValue = geometryProp ? this.getStringValue(geometryProp.value) : "box";
-        const scale = this.extractScale(obj);
-        this.emit("<geometry>");
-        this.indentLevel++;
-        switch (geometryValue) {
-          case "cube":
-          case "box":
-            this.emit(`<box><size>${scale} ${scale} ${scale}</size></box>`);
-            break;
-          case "sphere":
-            this.emit(`<sphere><radius>${scale / 2}</radius></sphere>`);
-            break;
-          case "cylinder":
-            this.emit(`<cylinder><radius>${scale / 2}</radius><length>${scale}</length></cylinder>`);
-            break;
-          case "plane":
-            this.emit(`<plane><normal>0 0 1</normal><size>${scale} ${scale}</size></plane>`);
-            break;
-          case "capsule":
-            this.emit(`<capsule><radius>${scale / 3}</radius><length>${scale}</length></capsule>`);
-            break;
-          default:
-            if (geometryValue.includes(".")) {
-              this.emit(`<mesh><uri>${this.options.meshPathPrefix}${geometryValue}</uri></mesh>`);
-            } else {
-              this.emit(`<box><size>${scale} ${scale} ${scale}</size></box>`);
-            }
-        }
-        this.indentLevel--;
-        this.emit("</geometry>");
-      }
-      emitMaterial(obj) {
-        const color = this.extractColor(obj);
-        this.emit("<material>");
-        this.indentLevel++;
-        if (color) {
-          const rgb = this.parseColor(color);
-          this.emit(`<ambient>${rgb.r} ${rgb.g} ${rgb.b} 1</ambient>`);
-          this.emit(`<diffuse>${rgb.r} ${rgb.g} ${rgb.b} 1</diffuse>`);
-          this.emit(`<specular>0.1 0.1 0.1 1</specular>`);
-          if (this.hasTrait(obj, "glowing") || this.hasTrait(obj, "emissive")) {
-            this.emit(`<emissive>${rgb.r * 0.5} ${rgb.g * 0.5} ${rgb.b * 0.5} 1</emissive>`);
-          }
-        } else {
-          this.emit("<ambient>0.7 0.7 0.7 1</ambient>");
-          this.emit("<diffuse>0.7 0.7 0.7 1</diffuse>");
-        }
-        this.indentLevel--;
-        this.emit("</material>");
-      }
-      extractPosition(obj) {
-        const posProp = obj.properties.find((p) => p.key === "position");
-        if (posProp && Array.isArray(posProp.value)) {
-          return [
-            Number(posProp.value[0]) || 0,
-            Number(posProp.value[1]) || 0,
-            Number(posProp.value[2]) || 0
-          ];
-        }
-        return [0, 0, 0];
-      }
-      extractRotation(obj) {
-        const rotProp = obj.properties.find((p) => p.key === "rotation");
-        if (rotProp && Array.isArray(rotProp.value)) {
-          return [
-            (Number(rotProp.value[0]) || 0) * Math.PI / 180,
-            (Number(rotProp.value[1]) || 0) * Math.PI / 180,
-            (Number(rotProp.value[2]) || 0) * Math.PI / 180
-          ];
-        }
-        return [0, 0, 0];
-      }
-      extractScale(obj) {
-        const scaleProp = obj.properties.find((p) => p.key === "scale");
-        if (scaleProp) {
-          if (typeof scaleProp.value === "number") return scaleProp.value;
-          if (Array.isArray(scaleProp.value)) return Number(scaleProp.value[0]) || 1;
-        }
-        return 1;
-      }
-      extractColor(obj) {
-        const colorProp = obj.properties.find((p) => p.key === "color");
-        return colorProp ? this.getStringValue(colorProp.value) : void 0;
-      }
-      extractMass(obj) {
-        const physicsProp = obj.properties.find((p) => p.key === "physics");
-        if (physicsProp && typeof physicsProp.value === "object" && !Array.isArray(physicsProp.value)) {
-          const massEntry = physicsProp.value.mass;
-          if (typeof massEntry === "number") return massEntry;
-        }
-        return void 0;
-      }
-      mapLightType(type) {
-        switch (type) {
-          case "point":
-            return "point";
-          case "directional":
-            return "directional";
-          case "spot":
-            return "spot";
-          default:
-            return "point";
-        }
-      }
-      parseColor(color) {
-        if (color.startsWith("#")) {
-          const hex = color.slice(1);
-          return {
-            r: parseInt(hex.slice(0, 2), 16) / 255,
-            g: parseInt(hex.slice(2, 4), 16) / 255,
-            b: parseInt(hex.slice(4, 6), 16) / 255
-          };
-        }
-        const colors = {
-          red: { r: 1, g: 0, b: 0 },
-          green: { r: 0, g: 1, b: 0 },
-          blue: { r: 0, g: 0, b: 1 },
-          white: { r: 1, g: 1, b: 1 },
-          black: { r: 0, g: 0, b: 0 },
-          yellow: { r: 1, g: 1, b: 0 },
-          cyan: { r: 0, g: 1, b: 1 },
-          magenta: { r: 1, g: 0, b: 1 }
-        };
-        return colors[color.toLowerCase()] || { r: 0.7, g: 0.7, b: 0.7 };
-      }
-      emit(line) {
-        const indent = "  ".repeat(this.indentLevel);
-        this.lines.push(indent + line);
-      }
-      sanitizeName(name) {
-        return name.replace(/[^a-zA-Z0-9_]/g, "_").toLowerCase();
-      }
-      escapeXml(str) {
-        return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-      }
-      getStringValue(value) {
-        if (typeof value === "string") return value;
-        if (typeof value === "number") return String(value);
-        if (typeof value === "boolean") return String(value);
-        return "";
-      }
-    };
-    SDFCompiler_default = SDFCompiler;
-  }
-});
-
-export { SDFCompiler, SDFCompiler_default, SDFCompiler_exports, init_SDFCompiler };
-//# sourceMappingURL=chunk-UERJ3YJV.js.map
-//# sourceMappingURL=chunk-UERJ3YJV.js.map