@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-OH2FAIVU.js

@@ -0,0 +1,608 @@
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, compilePhysicsBlock, physicsToSDF, compileMaterialBlock, materialToSDF } from './chunk-BOVPWH4H.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.js';
+import { __export, __esm } from './chunk-OL46QLBJ.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
+
+// 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",
+          gazeboVersion: options.gazeboVersion ?? "classic",
+          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.gazeboVersion === "harmonic") {
+          this.emitGzSimPlugins();
+        }
+        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);
+        if (composition.objects) {
+          for (const obj of composition.objects) {
+            const parent = this.extractParent(obj);
+            if (parent) {
+              this.emitJoint(obj, parent);
+            }
+          }
+        }
+        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("");
+      }
+      emitGzSimPlugins() {
+        this.emit("<!-- gz-sim system plugins (Harmonic) -->");
+        this.emit(`<plugin name="gz::sim::systems::Physics" filename="gz-sim-physics-system">`);
+        this.indentLevel++;
+        this.emit(`<engine>${this.options.physicsEngine}</engine>`);
+        this.indentLevel--;
+        this.emit("</plugin>");
+        this.emit(`<plugin name="gz::sim::systems::Sensors" filename="gz-sim-sensors-system">`);
+        this.indentLevel++;
+        this.emit("<render_engine>ogre2</render_engine>");
+        this.indentLevel--;
+        this.emit("</plugin>");
+        this.emit('<plugin name="gz::sim::systems::SceneBroadcaster" filename="gz-sim-scene-broadcaster-system" />');
+        this.emit('<plugin name="gz::sim::systems::Contact" filename="gz-sim-contact-system" />');
+        this.emit('<plugin name="gz::sim::systems::Imu" filename="gz-sim-imu-system" />');
+        this.emit('<plugin name="gz::sim::systems::JointStatePublisher" filename="gz-sim-joint-state-publisher-system" />');
+        this.emit("");
+      }
+      calculateInertia(geometry, mass, scale) {
+        switch (geometry) {
+          case "sphere": {
+            const r = scale / 2;
+            const i = 2 / 5 * mass * r * r;
+            return { ixx: i, ixy: 0, ixz: 0, iyy: i, iyz: 0, izz: i };
+          }
+          case "cylinder": {
+            const r = scale / 2;
+            const l = scale;
+            const ixx = mass * (3 * r * r + l * l) / 12;
+            const iyy = ixx;
+            const izz = mass * r * r / 2;
+            return { ixx, ixy: 0, ixz: 0, iyy, iyz: 0, izz };
+          }
+          case "capsule": {
+            const r = scale / 3;
+            const l = scale;
+            const ixx = mass * (3 * r * r + l * l) / 12;
+            const iyy = ixx;
+            const izz = mass * r * r / 2;
+            return { ixx, ixy: 0, ixz: 0, iyy, iyz: 0, izz };
+          }
+          case "box":
+          case "cube":
+          default: {
+            const w = scale;
+            const h = scale;
+            const d = scale;
+            const ixx = mass * (h * h + d * d) / 12;
+            const iyy = mass * (w * w + d * d) / 12;
+            const izz = mass * (w * w + h * h) / 12;
+            return { ixx, ixy: 0, ixz: 0, iyy, iyz: 0, izz };
+          }
+        }
+      }
+      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;
+          const geometry = this.extractGeometry(obj);
+          const scale = this.extractScale(obj);
+          const inertia = this.calculateInertia(geometry, mass, scale);
+          this.emit("<inertial>");
+          this.indentLevel++;
+          this.emit(`<mass>${mass}</mass>`);
+          this.emit("<inertia>");
+          this.indentLevel++;
+          this.emit(`<ixx>${inertia.ixx.toExponential(6)}</ixx>`);
+          this.emit(`<ixy>${inertia.ixy.toExponential(6)}</ixy>`);
+          this.emit(`<ixz>${inertia.ixz.toExponential(6)}</ixz>`);
+          this.emit(`<iyy>${inertia.iyy.toExponential(6)}</iyy>`);
+          this.emit(`<iyz>${inertia.iyz.toExponential(6)}</iyz>`);
+          this.emit(`<izz>${inertia.izz.toExponential(6)}</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 massProp = obj.properties.find((p) => p.key === "mass");
+        if (massProp && typeof massProp.value === "number") return massProp.value;
+        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;
+      }
+      extractGeometry(obj) {
+        const geometryProp = obj.properties.find((p) => p.key === "geometry");
+        return geometryProp ? this.getStringValue(geometryProp.value) : "box";
+      }
+      extractParent(obj) {
+        const parentProp = obj.properties.find((p) => p.key === "parent");
+        return parentProp ? this.getStringValue(parentProp.value) : void 0;
+      }
+      emitJoint(obj, parentName) {
+        const jointTypeProp = obj.properties.find((p) => p.key === "joint_type");
+        const jointType = jointTypeProp ? this.getStringValue(jointTypeProp.value) : "fixed";
+        const name = this.sanitizeName(obj.name);
+        const parent = this.sanitizeName(parentName);
+        this.emit(`<joint name="${name}_joint" type="${jointType}">`);
+        this.indentLevel++;
+        this.emit(`<parent>${parent}</parent>`);
+        this.emit(`<child>${name}</child>`);
+        const axisProp = obj.properties.find((p) => p.key === "axis");
+        if (axisProp && Array.isArray(axisProp.value)) {
+          const axis = axisProp.value.map((v) => Number(v) || 0).join(" ");
+          this.emit(`<axis>`);
+          this.indentLevel++;
+          this.emit(`<xyz>${axis}</xyz>`);
+          this.indentLevel--;
+          this.emit(`</axis>`);
+        }
+        this.indentLevel--;
+        this.emit("</joint>");
+        this.emit("");
+      }
+      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-OH2FAIVU.js.map
+//# sourceMappingURL=chunk-OH2FAIVU.js.map