@lovelace_lol/loom3 1.0.44 → 1.0.46

package/README.md

@@ -350,15 +350,20 @@ const loom = new Loom3({
 
 `annotationRegions` is the Loom3 field for camera/marker region defaults and profile overrides.
 
-If your app fetches a full saved `CharacterConfig` from Firestore or another backend, use `extendCharacterConfigWithPreset(...)` to build the runtime shape before handing that config to camera/marker tooling:
+If your app fetches a saved model/profile record from Firestore or another backend, use `extendProfileConfigWithPreset(...)` to build the runtime shape before handing that profile config to camera/marker tooling:
 
 ```typescript
-import { extendCharacterConfigWithPreset } from '@lovelace_lol/loom3';
+import { extendProfileConfigWithPreset } from '@lovelace_lol/loom3';
 
-const savedConfig = await fetchCharacterConfig();
-const runtimeConfig = extendCharacterConfigWithPreset(savedConfig);
+const savedConfig = await fetchProfileConfig();
+const runtimeConfig = extendProfileConfigWithPreset({
+  ...savedConfig,
+  profilePresetId: savedConfig.profilePresetId ?? 'cc4',
+});
 ```
 
+`CharacterConfig`, `auPresetType`, and `extendCharacterConfigWithPreset(...)` are still exported as deprecated compatibility aliases for apps migrating from older LoomLarge-style character records. New Loom3 integrations should model presets as base profiles, pass profile overrides through `profile`, `annotationRegions`, or other `Profile` fields, and use `profilePresetId` for preset selection.
+
 For the current runtime-oriented documentation, including:
 
 - `paddingFactor`
@@ -2091,7 +2096,7 @@ console.log(result.center, result.method, result.debugInfo);
 ### Resolving region-driven centers
 
 ```typescript
-import type { CharacterConfig, Region } from '@lovelace_lol/loom3';
+import type { BoneResolutionProfile, Region } from '@lovelace_lol/loom3';
 import { resolveBoneName, resolveBoneNames, resolveFaceCenter } from '@lovelace_lol/loom3';
 
 const region: Region = {
@@ -2100,18 +2105,14 @@ const region: Region = {
   meshes: ['CC_Base_Body'],
 };
 
-const config = {
-  characterId: 'demo',
-  characterName: 'Demo',
-  modelPath: '/demo.glb',
-  regions: [region],
+const profile: BoneResolutionProfile = {
   bonePrefix: 'CC_Base_',
   boneNodes: { HEAD: 'Head' },
-} satisfies CharacterConfig;
+};
 
-const headBone = resolveBoneName('HEAD', config);
-const resolvedBones = resolveBoneNames(['HEAD'], config);
-const faceCenter = resolveFaceCenter(gltf.scene, region, config);
+const headBone = resolveBoneName('HEAD', profile);
+const resolvedBones = resolveBoneNames(['HEAD'], profile);
+const faceCenter = resolveFaceCenter(gltf.scene, region, profile);
 ```
 
 ### Working with model orientation
@@ -2128,7 +2129,7 @@ const facing = detectFacingDirection(gltf.scene);
 
 Use these helpers when you need to:
 - place annotation markers using semantic regions instead of hard-coded coordinates
-- resolve prefixed/suffixed bone names from a reusable character config
+- resolve prefixed/suffixed bone names from a reusable profile or minimal bone-resolution object
 - derive a face anchor for camera tooling or interaction layers
 - reason about model orientation before building your own camera or annotation system
 

package/dist/index.cjs

@@ -7032,7 +7032,7 @@ function normalizeRegionTree(regions, disabledNames) {
   });
 }
 
-// src/characters/extendCharacterConfigWithPreset.ts
+// src/profiles/resolveProfileConfig.ts
 var PROFILE_OVERRIDE_KEYS = [
   "name",
   "animalType",
@@ -7139,7 +7139,7 @@ function mergeRegion(base, override) {
     } : void 0
   };
 }
-function mergeRegionsByName(base, override) {
+function mergeProfileRegionsByName(base, override) {
   if (!base && !override) return void 0;
   const merged = /* @__PURE__ */ new Map();
   for (const region of base ?? []) {
@@ -7154,6 +7154,10 @@ function mergeRegionsByName(base, override) {
 function getAnnotationRegions(value) {
   return Array.isArray(value) ? value : void 0;
 }
+var mergeRegionsByName = mergeProfileRegionsByName;
+function getProfilePresetId(config) {
+  return config.profilePresetId ?? config.presetId ?? config.baseProfileId ?? config.auPresetType;
+}
 function getLegacyNestedOverrides(config) {
   return isPlainObject2(config.profile) ? config.profile : {};
 }
@@ -7161,12 +7165,12 @@ function getLegacyRuntimeRegions(config) {
   return Array.isArray(config.regions) && config.regions.length > 0 ? config.regions : void 0;
 }
 function getCanonicalAnnotationOverrides(config) {
-  return mergeRegionsByName(
+  return mergeProfileRegionsByName(
     getAnnotationRegions(getLegacyNestedOverrides(config).annotationRegions),
     getAnnotationRegions(config.annotationRegions)
   );
 }
-function extractProfileOverrides(config) {
+function extractLegacyCharacterProfileOverrides(config) {
   const topLevelConfig = config;
   const legacyNestedOverrides = getLegacyNestedOverrides(config);
   const canonicalAnnotationOverrides = getCanonicalAnnotationOverrides(config);
@@ -7189,12 +7193,18 @@ function extractProfileOverrides(config) {
   }
   return overrides;
 }
-function applyCharacterProfileToPreset(config) {
-  const presetType = config.auPresetType;
+function extractProfileOverrides(config) {
+  return extractLegacyCharacterProfileOverrides(config);
+}
+function resolveProfileFromPreset(config) {
+  const presetType = getProfilePresetId(config);
   if (!presetType) {
     return null;
   }
-  return extendPresetWithProfile(getPreset(presetType), extractProfileOverrides(config));
+  return extendPresetWithProfile(getPreset(presetType), extractLegacyCharacterProfileOverrides(config));
+}
+function applyCharacterProfileToPreset(config) {
+  return resolveProfileFromPreset(config);
 }
 function orderExtendedRegions(extendedRegions, prioritizedLists) {
   if (!extendedRegions) return void 0;
@@ -7215,15 +7225,15 @@ function orderExtendedRegions(extendedRegions, prioritizedLists) {
   }
   return orderedNames.map((name) => extendedByName.get(name)).filter((region) => Boolean(region));
 }
-function extendCharacterConfigWithPreset(config) {
-  const presetType = config.auPresetType;
+function extendProfileConfigWithPreset(config) {
+  const presetType = getProfilePresetId(config);
   if (!presetType || presetType === "custom") {
     return config;
   }
   const canonicalAnnotationOverrides = getCanonicalAnnotationOverrides(config);
   const legacyRuntimeRegions = getLegacyRuntimeRegions(config);
-  const profileOverrides = extractProfileOverrides(config);
-  const extendedPresetProfile = applyCharacterProfileToPreset(config);
+  const profileOverrides = extractLegacyCharacterProfileOverrides(config);
+  const extendedPresetProfile = resolveProfileFromPreset(config);
   if (!extendedPresetProfile) {
     return config;
   }
@@ -7237,7 +7247,7 @@ function extendCharacterConfigWithPreset(config) {
   const extendedRegionNames = new Set((extendedAnnotationRegions ?? []).map((region) => region.name));
   const legacyExtraRegions = canonicalAnnotationOverrides && legacyRuntimeRegions ? legacyRuntimeRegions.filter((region) => !presetRegionNames.has(region.name) && !extendedRegionNames.has(region.name)).map((region) => cloneRegion(region)) : void 0;
   const mergedRegions = normalizeRegionTree(
-    mergeRegionsByName(extendedAnnotationRegions, legacyExtraRegions),
+    mergeProfileRegionsByName(extendedAnnotationRegions, legacyExtraRegions),
     profileOverrides.disabledRegions
   );
   const extendedRegions = orderExtendedRegions(
@@ -7251,6 +7261,9 @@ function extendCharacterConfigWithPreset(config) {
     regions: extendedRegions ?? config.regions
   };
 }
+function extendCharacterConfigWithPreset(config) {
+  return extendProfileConfigWithPreset(config);
+}
 var DEFAULT_EPSILON = 1e-4;
 var DEFAULT_YAW_WEIGHT = 0.35;
 var DEFAULT_PITCH_WEIGHT = 0.2;
@@ -7475,9 +7488,9 @@ function detectFacingDirection(model, eyeBoneNames = {
 function normalizeLooseName(value) {
   return value.replace(/\./g, "");
 }
-function resolveBoneNameCandidates(semanticName, config) {
-  if (!config) return [semanticName];
-  const { bonePrefix, boneSuffix, boneNodes } = config;
+function resolveBoneNameCandidates(semanticName, profile) {
+  if (!profile) return [semanticName];
+  const { bonePrefix, boneSuffix, boneNodes } = profile;
   if (!boneNodes || !boneNodes[semanticName]) {
     return [semanticName];
   }
@@ -7491,14 +7504,14 @@ function resolveBoneNameCandidates(semanticName, config) {
   const fullyAffixed = suffix && !prefixedBase.endsWith(suffix) ? `${prefixedBase}${suffix}` : prefixedBase;
   return Array.from(/* @__PURE__ */ new Set([fullyAffixed, baseName]));
 }
-function resolveBoneName(semanticName, config) {
-  return resolveBoneNameCandidates(semanticName, config)[0] ?? semanticName;
+function resolveBoneName(semanticName, profile) {
+  return resolveBoneNameCandidates(semanticName, profile)[0] ?? semanticName;
 }
-function resolveBoneNames(names, config) {
+function resolveBoneNames(names, profile) {
   if (!names || names.length === 0) return [];
   return Array.from(
     new Set(
-      names.flatMap((name) => resolveBoneNameCandidates(name, config))
+      names.flatMap((name) => resolveBoneNameCandidates(name, profile))
     )
   );
 }
@@ -7511,8 +7524,8 @@ function fuzzyNameMatch(objectName, targetName, suffixPattern) {
   const regex = suffixPattern ? new RegExp(suffixPattern) : /^[_\.]\d+$/;
   return regex.test(suffix);
 }
-function resolveFaceCenter(model, region, config) {
-  const resolvedBones = resolveBoneNames(region.bones, config);
+function resolveFaceCenter(model, region, profile) {
+  const resolvedBones = resolveBoneNames(region.bones, profile);
   const headBoneNames = resolvedBones.filter((name) => name.toLowerCase().includes("head"));
   const result = findFaceCenter(model, {
     headBoneNames: headBoneNames.length > 0 ? headBoneNames : void 0,
@@ -7525,6 +7538,274 @@ function resolveFaceCenter(model, region, config) {
   };
 }
 
+// src/camera/annotationCameraAngles.ts
+var DEFAULT_LATERALITY = {
+  leftSideX: -1,
+  confidence: 0,
+  evidence: ["default:left=-X"]
+};
+var SIDE_TOKEN_PATTERN = /(^|[_\s-])(left|right)(?=$|[_\s-])/i;
+var MIN_LATERAL_SEPARATION = 1e-3;
+function invertHorizontalSign(sign) {
+  return sign === 1 ? -1 : 1;
+}
+function averagePoints(points) {
+  if (points.length === 0) return null;
+  const center = new THREE2__namespace.Vector3();
+  for (const point of points) {
+    center.add(point);
+  }
+  return center.divideScalar(points.length);
+}
+function replaceSemanticSideToken(name, replacement) {
+  const match = SIDE_TOKEN_PATTERN.exec(name);
+  if (!match) return null;
+  const [fullMatch, prefix] = match;
+  const start = match.index;
+  const end = start + fullMatch.length;
+  return `${name.slice(0, start)}${prefix}${replacement}${name.slice(end)}`;
+}
+function collectMatchedPoints(model, targetNames, matcher, extractor) {
+  const points = [];
+  for (const targetName of targetNames) {
+    model.traverse((obj) => {
+      if (!matcher(obj, targetName)) return;
+      const point = extractor(obj);
+      if (point) {
+        points.push(point);
+      }
+    });
+  }
+  return points;
+}
+function getRegionWorldCenter(model, region, characterConfig) {
+  if (region.customPosition) {
+    return new THREE2__namespace.Vector3(
+      region.customPosition.x,
+      region.customPosition.y,
+      region.customPosition.z
+    );
+  }
+  if (region.objects?.includes("*")) {
+    return null;
+  }
+  const suffixPattern = characterConfig?.suffixPattern;
+  const points = [];
+  if (region.bones?.length) {
+    const boneNames = resolveBoneNames(region.bones, characterConfig ?? void 0);
+    points.push(
+      ...collectMatchedPoints(
+        model,
+        boneNames,
+        (obj, targetName) => fuzzyNameMatch(obj.name, targetName, suffixPattern),
+        (obj) => {
+          const worldPos = new THREE2__namespace.Vector3();
+          obj.getWorldPosition(worldPos);
+          return worldPos;
+        }
+      )
+    );
+  }
+  if (region.meshes?.length) {
+    points.push(
+      ...collectMatchedPoints(
+        model,
+        region.meshes,
+        (obj, targetName) => obj.isMesh && fuzzyNameMatch(obj.name, targetName, suffixPattern),
+        (obj) => {
+          const box = new THREE2__namespace.Box3().setFromObject(obj);
+          if (box.isEmpty()) {
+            return null;
+          }
+          return box.getCenter(new THREE2__namespace.Vector3());
+        }
+      )
+    );
+  }
+  if (region.objects?.length) {
+    const objectTargets = region.objects.filter((target) => target !== "*");
+    points.push(
+      ...collectMatchedPoints(
+        model,
+        objectTargets,
+        (obj, targetName) => fuzzyNameMatch(obj.name, targetName, suffixPattern),
+        (obj) => {
+          if (obj.isMesh) {
+            const box = new THREE2__namespace.Box3().setFromObject(obj);
+            if (!box.isEmpty()) {
+              return box.getCenter(new THREE2__namespace.Vector3());
+            }
+          }
+          const worldPos = new THREE2__namespace.Vector3();
+          obj.getWorldPosition(worldPos);
+          return worldPos;
+        }
+      )
+    );
+  }
+  return averagePoints(points);
+}
+function getRegionLocalCenter(model, region, characterConfig) {
+  const worldCenter = getRegionWorldCenter(model, region, characterConfig);
+  return worldCenter ? model.worldToLocal(worldCenter.clone()) : null;
+}
+function cloneLaterality(value) {
+  return {
+    leftSideX: value.leftSideX,
+    confidence: value.confidence,
+    evidence: [...value.evidence]
+  };
+}
+function getDefaultAnnotationLaterality() {
+  return cloneLaterality(DEFAULT_LATERALITY);
+}
+function normalizeCameraAngle(angle) {
+  return (angle % 360 + 360) % 360;
+}
+function getRegionSemanticSide(regionName) {
+  if (!regionName) return null;
+  const match = SIDE_TOKEN_PATTERN.exec(regionName);
+  if (!match) return null;
+  return match[2].toLowerCase() === "left" ? "left" : "right";
+}
+function getSemanticHorizontalSign(regionName, laterality) {
+  const side = getRegionSemanticSide(regionName);
+  if (side === "left") return laterality.leftSideX;
+  if (side === "right") return invertHorizontalSign(laterality.leftSideX);
+  return null;
+}
+function getSemanticHorizontalSignForSide(side, laterality) {
+  return side === "left" ? laterality.leftSideX : invertHorizontalSign(laterality.leftSideX);
+}
+function detectAnnotationLaterality(model, regions, characterConfig) {
+  if (!model || regions.length === 0) {
+    return getDefaultAnnotationLaterality();
+  }
+  model.updateMatrixWorld(true);
+  const regionsByName = new Map(
+    regions.map((region) => [region.name.toLowerCase(), region])
+  );
+  const votes = [];
+  const pairedKeys = /* @__PURE__ */ new Set();
+  for (const region of regions) {
+    if (getRegionSemanticSide(region.name) !== "left") continue;
+    const mirroredName = replaceSemanticSideToken(region.name, "right");
+    if (!mirroredName) continue;
+    const other = regionsByName.get(mirroredName.toLowerCase());
+    if (!other) continue;
+    const pairKey = [region.name.toLowerCase(), other.name.toLowerCase()].sort().join("|");
+    if (pairedKeys.has(pairKey)) continue;
+    pairedKeys.add(pairKey);
+    const leftCenter = getRegionLocalCenter(model, region, characterConfig);
+    const rightCenter = getRegionLocalCenter(model, other, characterConfig);
+    if (!leftCenter || !rightCenter) continue;
+    const separation = Math.abs(leftCenter.x - rightCenter.x);
+    if (separation < MIN_LATERAL_SEPARATION) continue;
+    votes.push({
+      sign: leftCenter.x > rightCenter.x ? 1 : -1,
+      weight: separation,
+      evidence: `pair:${region.name}/${other.name}:${leftCenter.x.toFixed(3)}/${rightCenter.x.toFixed(3)}`
+    });
+  }
+  if (votes.length === 0) {
+    for (const region of regions) {
+      const side = getRegionSemanticSide(region.name);
+      if (!side) continue;
+      const center = getRegionLocalCenter(model, region, characterConfig);
+      if (!center || Math.abs(center.x) < MIN_LATERAL_SEPARATION) continue;
+      const sign = side === "left" ? center.x > 0 ? 1 : -1 : center.x > 0 ? -1 : 1;
+      votes.push({
+        sign,
+        weight: Math.abs(center.x),
+        evidence: `single:${region.name}:${center.x.toFixed(3)}`
+      });
+    }
+  }
+  if (votes.length === 0) {
+    return getDefaultAnnotationLaterality();
+  }
+  let signedWeight = 0;
+  let totalWeight = 0;
+  for (const vote of votes) {
+    signedWeight += vote.sign * vote.weight;
+    totalWeight += vote.weight;
+  }
+  if (Math.abs(signedWeight) < MIN_LATERAL_SEPARATION) {
+    return getDefaultAnnotationLaterality();
+  }
+  return {
+    leftSideX: signedWeight > 0 ? 1 : -1,
+    confidence: totalWeight > 0 ? Math.abs(signedWeight) / totalWeight : 0,
+    evidence: votes.map((vote) => vote.evidence)
+  };
+}
+function resolveRegionCameraAngle(region, laterality) {
+  if (region.cameraAngle === void 0) {
+    return void 0;
+  }
+  const normalizedAngle = normalizeCameraAngle(region.cameraAngle);
+  const side = getRegionSemanticSide(region.name);
+  if (side && (normalizedAngle === 90 || normalizedAngle === 270)) {
+    return side === "left" ? laterality.leftSideX > 0 ? 90 : 270 : laterality.leftSideX > 0 ? 270 : 90;
+  }
+  return normalizedAngle;
+}
+function resolveRegionVisibilityCameraAngle(region, laterality) {
+  const explicitAngle = resolveRegionCameraAngle(region, laterality);
+  if (explicitAngle !== void 0) {
+    return explicitAngle;
+  }
+  if (!region.parent) {
+    return void 0;
+  }
+  const side = getRegionSemanticSide(region.name);
+  if (!side) {
+    return void 0;
+  }
+  return side === "left" ? laterality.leftSideX > 0 ? 90 : 270 : laterality.leftSideX > 0 ? 270 : 90;
+}
+function toWorldDirection(model, localDirection) {
+  const worldDirection = localDirection.clone();
+  if (model) {
+    model.updateMatrixWorld(true);
+    const worldQuaternion = new THREE2__namespace.Quaternion();
+    model.getWorldQuaternion(worldQuaternion);
+    worldDirection.applyQuaternion(worldQuaternion);
+  }
+  return worldDirection.normalize();
+}
+function toModelLocalDirection2(model, worldDirection) {
+  const localDirection = worldDirection.clone();
+  if (model) {
+    model.updateMatrixWorld(true);
+    const worldQuaternion = new THREE2__namespace.Quaternion();
+    model.getWorldQuaternion(worldQuaternion);
+    localDirection.applyQuaternion(worldQuaternion.invert());
+  }
+  return localDirection.normalize();
+}
+function getWorldDirectionForCameraAngle(model, cameraAngle) {
+  const angleRad = normalizeCameraAngle(cameraAngle) * Math.PI / 180;
+  return toWorldDirection(
+    model,
+    new THREE2__namespace.Vector3(Math.sin(angleRad), 0, Math.cos(angleRad))
+  );
+}
+function getModelLocalOrbitAngle(model, modelCenter, worldPosition) {
+  const worldOffset = new THREE2__namespace.Vector3().subVectors(worldPosition, modelCenter);
+  const localOffset = toModelLocalDirection2(model, worldOffset);
+  return normalizeCameraAngle(Math.atan2(localOffset.x, localOffset.z) * (180 / Math.PI));
+}
+function passesMarkerCameraAngleGate(params) {
+  const { markerAngle, currentCameraAngle, rangeDegrees = 90 } = params;
+  if (markerAngle === void 0 || markerAngle === 0 || currentCameraAngle === void 0) {
+    return true;
+  }
+  let diff = Math.abs(currentCameraAngle - markerAngle);
+  if (diff > 180) diff = 360 - diff;
+  return diff <= rangeDegrees;
+}
+
 // src/physics/HairPhysics.ts
 var DEFAULT_HAIR_PHYSICS_CONFIG = {
   mass: 1,
@@ -8668,36 +8949,54 @@ exports.buildMappingEditorModel = buildMappingEditorModel;
 exports.collectMorphMeshes = collectMorphMeshes;
 exports.compileVisemeKeys = compileVisemeKeys;
 exports.computeCameraRelativeGazeOffset = computeCameraRelativeGazeOffset;
+exports.detectAnnotationLaterality = detectAnnotationLaterality;
 exports.detectFacingDirection = detectFacingDirection;
 exports.extendCharacterConfigWithPreset = extendCharacterConfigWithPreset;
 exports.extendPresetWithProfile = extendPresetWithProfile;
+exports.extendProfileConfigWithPreset = extendProfileConfigWithPreset;
 exports.extractFromGLTF = extractFromGLTF;
+exports.extractLegacyCharacterProfileOverrides = extractLegacyCharacterProfileOverrides;
 exports.extractModelData = extractModelData;
 exports.extractProfileOverrides = extractProfileOverrides;
 exports.findFaceCenter = findFaceCenter;
 exports.fuzzyNameMatch = fuzzyNameMatch;
 exports.generateMappingCorrections = generateMappingCorrections;
+exports.getDefaultAnnotationLaterality = getDefaultAnnotationLaterality;
 exports.getMeshNamesForAUProfile = getMeshNamesForAUProfile;
 exports.getMeshNamesForVisemeProfile = getMeshNamesForVisemeProfile;
 exports.getModelForwardDirection = getModelForwardDirection;
+exports.getModelLocalOrbitAngle = getModelLocalOrbitAngle;
 exports.getPreset = getPreset;
 exports.getPresetWithProfile = getPresetWithProfile;
+exports.getProfilePresetId = getProfilePresetId;
 exports.getProfileVisemeSlots = getProfileVisemeSlots;
+exports.getRegionSemanticSide = getRegionSemanticSide;
+exports.getSemanticHorizontalSign = getSemanticHorizontalSign;
+exports.getSemanticHorizontalSignForSide = getSemanticHorizontalSignForSide;
 exports.getVisemeBindingTargets = getVisemeBindingTargets;
 exports.getVisemeJawAmounts = getVisemeJawAmounts;
 exports.getVisemeSlotIndex = getVisemeSlotIndex;
+exports.getWorldDirectionForCameraAngle = getWorldDirectionForCameraAngle;
 exports.hasLeftRightMorphs = hasLeftRightMorphs;
 exports.isMixedAU = isMixedAU;
 exports.isPresetCompatible = isPresetCompatible;
 exports.mapProviderVisemeToSlot = mapProviderVisemeToSlot;
 exports.mergeCharacterRegionsByName = mergeRegionsByName;
+exports.mergeProfileRegionsByName = mergeProfileRegionsByName;
+exports.normalizeCameraAngle = normalizeCameraAngle;
+exports.passesMarkerCameraAngleGate = passesMarkerCameraAngleGate;
 exports.resolveBoneName = resolveBoneName;
 exports.resolveBoneNames = resolveBoneNames;
 exports.resolveFaceCenter = resolveFaceCenter;
 exports.resolvePreset = resolvePreset;
 exports.resolvePresetWithOverrides = resolvePresetWithOverrides;
+exports.resolveProfileFromPreset = resolveProfileFromPreset;
+exports.resolveRegionCameraAngle = resolveRegionCameraAngle;
+exports.resolveRegionVisibilityCameraAngle = resolveRegionVisibilityCameraAngle;
 exports.resolveVisemeMeshCategory = resolveVisemeMeshCategory;
 exports.suggestBestPreset = suggestBestPreset;
+exports.toModelLocalDirection = toModelLocalDirection2;
+exports.toWorldDirection = toWorldDirection;
 exports.validateMappingConfig = validateMappingConfig;
 exports.validateMappings = validateMappings;
 //# sourceMappingURL=index.cjs.map