brep-io-kernel 1.0.0-ci.10

package/src/UI/pmi/AnnotationHistory.js

@@ -0,0 +1,353 @@
+import { annotationRegistry } from './AnnotationRegistry.js';
+import { deepClone } from '../../utils/deepClone.js';
+import { normalizeTypeString } from '../../utils/normalizeTypeString.js';
+import { HistoryCollectionBase } from '../../core/entities/HistoryCollectionBase.js';
+
+const RESERVED_INPUT_KEYS = new Set(['type', 'persistentData', '__open']);
+const DEFAULT_TYPE = 'annotation';
+
+export class AnnotationHistory extends HistoryCollectionBase {
+  constructor(pmimode = null) {
+    super({ viewer: pmimode?.viewer || null });
+    this.pmimode = pmimode || null;
+    this.#registerAvailableAnnotations();
+  }
+
+  setPMIMode(pmimode) {
+    this.pmimode = pmimode || null;
+    if (pmimode?.viewer) {
+      this.viewer = pmimode.viewer;
+    }
+  }
+
+  load(serializedAnnotations) {
+    this.entries = [];
+    this._idCounter = 0;
+    const list = Array.isArray(serializedAnnotations) ? serializedAnnotations : [];
+    for (const raw of list) {
+      const entity = this.#hydrateEntity(raw);
+      if (!entity) continue;
+      this.entries.push(entity);
+      this.#bumpIdCounterFrom(entity);
+      this.#linkInputParams(entity);
+    }
+    this.notifyListeners({ reason: 'load', history: this });
+    return this.entries;
+  }
+
+  toSerializable() {
+    return this.entries.map((entity) => {
+      const open = Boolean(entity.runtimeAttributes?.__open);
+      const input = deepClone(entity.inputParams || {});
+      if (input && typeof input === 'object') {
+        delete input.persistentData;
+        delete input.__open;
+        delete input.__entityRef;
+      }
+      return {
+        type: entity.type || DEFAULT_TYPE,
+        inputParams: input,
+        persistentData: deepClone(entity.persistentData || {}),
+        __open: open || undefined,
+        enabled: entity.enabled !== false,
+      };
+    });
+  }
+
+  get size() {
+    return this.entries.length;
+  }
+
+  getEntries() {
+    return this.entries.slice();
+  }
+
+  getEntry(index) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.entries.length) return null;
+    return this.entries[index] || null;
+  }
+
+  findById(entryId) {
+    if (entryId == null) return null;
+    const target = String(entryId);
+    if (!target) return null;
+    for (const entity of this.entries) {
+      const params = entity?.inputParams;
+      const candidate = params?.id ?? entity?.id;
+      if (candidate != null && String(candidate) === target) {
+        return entity;
+      }
+    }
+    return null;
+  }
+
+  setAnnotationEnabled(annotationId, enabled) {
+    const entry = this.findById(annotationId);
+    if (!entry) return false;
+    const next = enabled !== false;
+    const prev = entry.enabled !== false;
+    if (prev === next) return false;
+    this.#applyEnabledState(entry, next);
+    this.notifyListeners({ reason: 'update', entry, history: this });
+    return true;
+  }
+
+  createAnnotation(type, initialData = null) {
+    const EntityClass = this.#resolveHandler(type);
+    if (!EntityClass) return null;
+    const entity = new EntityClass({ history: this, registry: this.registry });
+    entity.type = EntityClass.entityType || EntityClass.type || normalizeTypeString(type) || DEFAULT_TYPE;
+    entity.entityType = entity.type;
+    const defaults = this.#defaultsFromSchema(EntityClass);
+    const seed = deepClone(initialData || {});
+    const params = { ...defaults, ...seed };
+    if (!params.type) params.type = entity.type;
+    entity.setParams(params);
+    entity.setPersistentData(params.persistentData || {});
+    delete entity.inputParams.persistentData;
+    this.#linkInputParams(entity);
+
+    if (typeof EntityClass.applyParams === 'function') {
+      try {
+        const res = EntityClass.applyParams(this.pmimode, entity.inputParams, entity.inputParams) || null;
+        if (res && res.paramsPatch && typeof res.paramsPatch === 'object') {
+          entity.mergeParams(res.paramsPatch);
+        }
+      } catch {
+        // ignore apply errors
+      }
+    }
+
+    const id = entity.inputParams.id || this.generateId(entity.shortName || entity.type || 'ANN');
+    entity.setId(id);
+    entity.runtimeAttributes.__open = true;
+    this.#applyEnabledState(entity, true);
+    this.entries.push(entity);
+    this.#bumpIdCounterFrom(entity);
+    this.notifyListeners({ reason: 'add', entry: entity, history: this });
+    return entity;
+  }
+
+  removeAt(index) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.entries.length) return null;
+    const [entity] = this.entries.splice(index, 1);
+    if (!entity) return null;
+    this.notifyListeners({ reason: 'remove', entry: entity, history: this });
+    return entity;
+  }
+
+  moveUp(index) {
+    if (!Number.isInteger(index) || index <= 0 || index >= this.entries.length) return false;
+    const [entity] = this.entries.splice(index, 1);
+    this.entries.splice(index - 1, 0, entity);
+    this.notifyListeners({ reason: 'reorder', entry: entity, history: this });
+    return true;
+  }
+
+  moveDown(index) {
+    if (!Number.isInteger(index) || index < 0 || index >= this.entries.length - 1) return false;
+    const [entity] = this.entries.splice(index, 1);
+    this.entries.splice(index + 1, 0, entity);
+    this.notifyListeners({ reason: 'reorder', entry: entity, history: this });
+    return true;
+  }
+
+  clear() {
+    this.entries = [];
+    this._idCounter = 0;
+    this.notifyListeners({ reason: 'clear', history: this });
+  }
+
+  generateId(typeHint = 'ANN') {
+    const safeHint = normalizeTypeString(typeHint) || 'ann';
+    const prefix = safeHint.replace(/[^a-z0-9]/gi, '').toUpperCase() || 'ANN';
+    const existing = new Set(this.entries.map((entity, i) => {
+      const params = entity?.inputParams;
+      if (params?.id) return String(params.id);
+      if (entity?.id != null) return String(entity.id);
+      return `ANN${i + 1}`;
+    }));
+    let candidate = '';
+    do {
+      this._idCounter += 1;
+      candidate = `${prefix}${this._idCounter}`;
+    } while (existing.has(candidate));
+    return candidate;
+  }
+
+  addListener(listener) {
+    if (typeof listener !== 'function') return () => {};
+    this._listeners.add(listener);
+    return () => {
+      try { this._listeners.delete(listener); } catch {
+        // ignore
+      }
+    };
+  }
+
+  removeListener(listener) {
+    if (typeof listener !== 'function') return;
+    try { this._listeners.delete(listener); } catch {
+      // ignore
+    }
+  }
+
+  notifyListeners(payload = {}) {
+    if (!(this._listeners instanceof Set)) return;
+    for (const fn of Array.from(this._listeners)) {
+      try { fn(payload, this); } catch {
+        // ignore listener errors
+      }
+    }
+  }
+
+  #hydrateEntity(raw) {
+    const source = raw && typeof raw === 'object' ? raw : {};
+    const type = normalizeTypeString(source.type || source.inputParams?.type || DEFAULT_TYPE) || DEFAULT_TYPE;
+    const EntityClass = this.#resolveHandler(type);
+    if (!EntityClass) return null;
+    const entity = new EntityClass({ history: this, registry: this.registry });
+    entity.type = EntityClass.entityType || EntityClass.type || type;
+    entity.entityType = entity.type;
+
+    const params = this.#cloneWithoutReserved(source.inputParams || source);
+    if (!params.type) params.type = entity.type;
+    entity.setParams(params);
+    entity.setPersistentData(deepClone(source.persistentData || {}));
+    delete entity.inputParams.persistentData;
+
+    if (typeof EntityClass.applyParams === 'function') {
+      try {
+        const res = EntityClass.applyParams(this.pmimode, entity.inputParams, entity.inputParams) || null;
+        if (res && res.paramsPatch && typeof res.paramsPatch === 'object') {
+          entity.mergeParams(res.paramsPatch);
+        }
+      } catch {
+        // ignore
+      }
+    }
+
+    const id = entity.inputParams.id || source.id || this.generateId(entity.shortName || entity.type);
+    entity.setId(id);
+    entity.runtimeAttributes.__open = Boolean(source.__open);
+    this.#applyEnabledState(entity, source.enabled);
+    this.#linkInputParams(entity);
+    return entity;
+  }
+
+  #linkInputParams(entity) {
+    if (!entity) return;
+    if (!entity.runtimeAttributes || typeof entity.runtimeAttributes !== 'object') {
+      entity.runtimeAttributes = {};
+    }
+    const params = entity.inputParams || {};
+    const descriptor = { configurable: true, enumerable: false };
+
+    if (!Object.prototype.hasOwnProperty.call(params, '__entityRef')) {
+      Object.defineProperty(params, '__entityRef', { ...descriptor, value: entity });
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(params, 'persistentData')) {
+      Object.defineProperty(params, 'persistentData', {
+        ...descriptor,
+        get: () => entity.persistentData,
+        set: (value) => {
+          const next = (value && typeof value === 'object') ? value : {};
+          entity.setPersistentData(next);
+        },
+      });
+    }
+
+    if (!Object.prototype.hasOwnProperty.call(params, '__open')) {
+      Object.defineProperty(params, '__open', {
+        ...descriptor,
+        get: () => Boolean(entity.runtimeAttributes.__open),
+        set: (value) => {
+          entity.runtimeAttributes.__open = Boolean(value);
+        },
+      });
+    }
+
+    params.type = entity.type || params.type || DEFAULT_TYPE;
+    if (params.id == null && entity.id != null) {
+      params.id = entity.id;
+    }
+  }
+
+  #defaultsFromSchema(EntityClass) {
+    const out = {};
+    const schema = EntityClass?.inputParamsSchema;
+    if (!schema || typeof schema !== 'object') return out;
+    for (const key of Object.keys(schema)) {
+      if (RESERVED_INPUT_KEYS.has(key)) continue;
+      const def = schema[key];
+      if (!def || typeof def !== 'object') continue;
+      if ('defaultResolver' in def && typeof def.defaultResolver === 'function') {
+        try {
+          const resolved = def.defaultResolver({ pmimode: this.pmimode, handler: EntityClass });
+          if (resolved !== undefined) {
+            out[key] = deepClone(resolved);
+            continue;
+          }
+        } catch {
+          // ignore resolver errors
+        }
+      }
+      if ('default_value' in def) {
+        out[key] = deepClone(def.default_value);
+      }
+    }
+    return out;
+  }
+
+  #cloneWithoutReserved(obj) {
+    const out = {};
+    if (!obj || typeof obj !== 'object') return out;
+    for (const key of Object.keys(obj)) {
+      if (RESERVED_INPUT_KEYS.has(key)) continue;
+      out[key] = deepClone(obj[key]);
+    }
+    return out;
+  }
+
+  #registerAvailableAnnotations() {
+    const list = annotationRegistry.list();
+    for (const Handler of list) {
+      try { this.registry.register(Handler); } catch {
+        // ignore duplicate registrations
+      }
+    }
+  }
+
+  #resolveHandler(type) {
+    const handler = annotationRegistry.getSafe?.(type) || null;
+    if (handler) {
+      try { this.registry.register(handler); } catch {
+        // ignore duplicate
+      }
+    }
+    return handler;
+  }
+
+  #bumpIdCounterFrom(entity) {
+    const id = entity?.inputParams?.id || entity?.id;
+    if (!id) return;
+    const match = String(id).match(/(\d+)$/);
+    if (!match) return;
+    const num = parseInt(match[1], 10);
+    if (Number.isFinite(num) && num > this._idCounter) {
+      this._idCounter = num;
+    }
+  }
+
+  #applyEnabledState(entity, value) {
+    if (!entity) return false;
+    const enabled = value !== false;
+    entity.enabled = enabled;
+    if (!entity.runtimeAttributes || typeof entity.runtimeAttributes !== 'object') {
+      entity.runtimeAttributes = {};
+    }
+    entity.runtimeAttributes.__enabled = enabled;
+    return enabled;
+  }
+}

package/src/UI/pmi/AnnotationRegistry.js

@@ -0,0 +1,90 @@
+// Simple registry for PMI annotation types. Allows lookup by type string or aliases.
+
+import { LinearDimensionAnnotation } from './dimensions/LinearDimensionAnnotation.js';
+import { RadialDimensionAnnotation } from './dimensions/RadialDimensionAnnotation.js';
+import { AngleDimensionAnnotation } from './dimensions/AngleDimensionAnnotation.js';
+import { LeaderAnnotation } from './dimensions/LeaderAnnotation.js';
+import { NoteAnnotation } from './dimensions/NoteAnnotation.js';
+import { ExplodeBodyAnnotation } from './dimensions/ExplodeBodyAnnotation.js';
+import { HoleCalloutAnnotation } from './dimensions/HoleCalloutAnnotation.js';
+
+const normalizeKey = (name) => {
+  if (!name && name !== 0) return '';
+  return String(name).trim().toLowerCase();
+};
+
+class AnnotationRegistry {
+  constructor() {
+    this._map = new Map();
+    this._aliases = new Map();
+  }
+
+  register(handler) {
+    if (!handler) return;
+    if (typeof handler === 'function') {
+      const ctor = handler;
+      if (!ctor.shortName) {
+        ctor.shortName = ctor.featureShortName || ctor.name || ctor.type || 'ANN';
+      }
+      if (!ctor.longName) {
+        ctor.longName = ctor.featureName || ctor.name || ctor.shortName || ctor.type || 'Annotation';
+      }
+    }
+    const typeKey = normalizeKey(
+      handler.type
+      || handler.shortName
+      || handler.featureShortName
+      || handler.name
+      || handler.longName
+      || handler.featureName,
+    );
+    if (!typeKey) return;
+    this._map.set(typeKey, handler);
+
+    if (Array.isArray(handler.aliases)) {
+      for (const alias of handler.aliases) {
+        const aliasKey = normalizeKey(alias);
+        if (aliasKey) this._aliases.set(aliasKey, handler);
+      }
+    }
+  }
+
+  get(name) {
+    const key = normalizeKey(name);
+    if (!key) {
+      throw new Error('Annotation type must be a non-empty string');
+    }
+    const handler = this._map.get(key) || this._aliases.get(key);
+    if (!handler) {
+      throw new Error(`Annotation type "${name}" is not registered.`);
+    }
+    return handler;
+  }
+
+  getSafe(name) {
+    try {
+      return this.get(name);
+    } catch {
+      return null;
+    }
+  }
+
+  has(name) {
+    return !!this.getSafe(name);
+  }
+
+  list() {
+    return Array.from(this._map.values());
+  }
+}
+
+export const annotationRegistry = new AnnotationRegistry();
+
+// Register built-in annotation handlers once
+annotationRegistry.register(LinearDimensionAnnotation);
+annotationRegistry.register(RadialDimensionAnnotation);
+annotationRegistry.register(AngleDimensionAnnotation);
+annotationRegistry.register(LeaderAnnotation);
+annotationRegistry.register(NoteAnnotation);
+annotationRegistry.register(ExplodeBodyAnnotation);
+annotationRegistry.register(HoleCalloutAnnotation);

package/src/UI/pmi/BaseAnnotation.js

@@ -0,0 +1,269 @@
+// BaseAnnotation.js
+// Base class for all PMI annotations built on the shared list entity foundation.
+
+import * as THREE from 'three';
+import { ListEntityBase } from '../../core/entities/ListEntityBase.js';
+
+export class BaseAnnotation extends ListEntityBase {
+  static entityType = 'annotation';
+  static shortName = 'ANN';
+  static longName = 'Annotation';
+  static inputParamsSchema = {}; 
+
+  constructor(opts = {}) {
+    super({ history: opts.history || null, registry: opts.registry || null });
+    this.resultArtifacts = [];
+  }
+
+  async run(renderingContext) {
+    // Base implementation - subclasses should override
+    // renderingContext contains: { pmimode, group, idx, ctx }
+    console.warn(`BaseAnnotation.run() not implemented for ${this.constructor.name}`);
+    return [];
+  }
+
+  // Helper methods that annotations can use
+  getScene() {
+    const partHistory = this.renderingContext?.pmimode?.viewer?.partHistory;
+    return partHistory?.scene || null;
+  }
+
+  getObjectByName(name) {
+    const scene = this.getScene();
+    return scene ? scene.getObjectByName(name) : null;
+  }
+
+  // Schema helpers mirror feature engine: schema drives UI, no extra per-ann plumbing
+  static getSchema(pmimode, ann) {
+    const schema = {};
+    const params = {};
+    const input = ann || {};
+
+    for (const key in this.inputParamsSchema) {
+      if (!Object.prototype.hasOwnProperty.call(this.inputParamsSchema, key)) continue;
+      const def = this.inputParamsSchema[key] || {};
+      const clonedDef = { ...def };
+      const currentValue = Object.prototype.hasOwnProperty.call(input, key)
+        ? __cloneValue(input[key])
+        : __cloneValue(def.default_value);
+      if (clonedDef && Object.prototype.hasOwnProperty.call(clonedDef, 'default_value')) {
+        clonedDef.default_value = __cloneValue(currentValue);
+      }
+      schema[key] = clonedDef;
+      params[key] = currentValue;
+    }
+
+    return { schema, params };
+  }
+
+  static applyParams(pmimode, ann, params) {
+    const sanitized = sanitizeAnnotationParams(this.inputParamsSchema, params, ann);
+    Object.assign(ann, sanitized);
+    return { paramsPatch: {} };
+  }
+
+  static ensurePersistentData(ann) {
+    if (!ann || typeof ann !== 'object') return null;
+    if (!ann.persistentData || typeof ann.persistentData !== 'object') {
+      ann.persistentData = {};
+    }
+    return ann.persistentData;
+  }
+
+  /**
+   * Shared label-drag helper. Creates a drag plane and wires pointer events so subclasses only
+   * need to provide the plane and what to do on drag.
+   */
+  static dragLabelOnPlane(pmimode, ctx, options = {}) {
+    if (!ctx || typeof options.makePlane !== 'function') return;
+    const plane = options.makePlane();
+    if (!plane || (!(plane instanceof THREE.Plane) && !plane.isPlane)) return;
+    const target = options.eventTarget || window;
+    const viewer = pmimode?.viewer;
+
+    const onMove = (ev) => {
+      const ray = ctx.raycastFromEvent ? ctx.raycastFromEvent(ev) : null;
+      if (!ray) return;
+      const hit = new THREE.Vector3();
+      const intersected = ctx.intersectPlane
+        ? ctx.intersectPlane(ray, plane, hit)
+        : ray.intersectPlane(plane, hit);
+      if (!intersected) return;
+      if (typeof options.onDrag === 'function') {
+        options.onDrag(hit, ev, plane);
+      }
+    };
+
+    const onUp = (ev) => {
+      try { target.removeEventListener('pointermove', onMove, true); } catch { }
+      try { target.removeEventListener('pointerup', onUp, true); } catch { }
+      if (options.suspendControls === true) {
+        try { if (viewer?.controls) viewer.controls.enabled = true; } catch { }
+      }
+      try { pmimode?.hideDragPlaneHelper?.(); } catch { }
+      if (typeof options.onEnd === 'function') {
+        try { options.onEnd(ev); } catch { /* ignore */ }
+      }
+      if (options.preventDefault !== false) {
+        try { ev.preventDefault(); ev.stopImmediatePropagation?.(); ev.stopPropagation(); } catch { }
+      }
+    };
+
+    try { pmimode?.showDragPlaneHelper?.(plane); } catch { }
+    if (options.suspendControls === true) {
+      try { if (viewer?.controls) viewer.controls.enabled = false; } catch { }
+    }
+
+    try { target.addEventListener('pointermove', onMove, true); } catch { }
+    try { target.addEventListener('pointerup', onUp, true); } catch { }
+  }
+
+  onIdChanged() {
+    if (!this.inputParams || typeof this.inputParams !== 'object') {
+      this.inputParams = {};
+    }
+    this.inputParams.id = this.id;
+  }
+
+  onParamsChanged() {
+    if (!this.inputParams || typeof this.inputParams !== 'object') {
+      this.inputParams = {};
+    }
+    if (!this.inputParams.id) {
+      this.inputParams.id = this.id;
+    }
+    if (!this.inputParams.type) {
+      this.inputParams.type = this.type || this.entityType || 'annotation';
+    }
+  }
+
+  onPersistentDataChanged() {
+    // Ensure persistentData is always an object for UI bindings
+    if (!this.persistentData || typeof this.persistentData !== 'object') {
+      this.persistentData = {};
+    }
+  }
+}
+
+function sanitizeAnnotationParams(schema, rawParams, ann) {
+  const sanitized = {};
+  const params = rawParams && typeof rawParams === 'object' ? rawParams : {};
+
+  for (const key in schema) {
+    if (!Object.prototype.hasOwnProperty.call(schema, key)) continue;
+    const def = schema[key] || {};
+    if (def.readOnly) {
+      // Preserve existing read-only values or fall back to defaults
+      if (ann && Object.prototype.hasOwnProperty.call(ann, key)) {
+        sanitized[key] = ann[key];
+      } else {
+        sanitized[key] = __cloneValue(def.default_value);
+      }
+      continue;
+    }
+    const value = params[key];
+    const hasExisting = ann && Object.prototype.hasOwnProperty.call(ann, key);
+    if (value === undefined) {
+      sanitized[key] = hasExisting ? __cloneValue(ann[key]) : __cloneValue(def.default_value);
+      continue;
+    }
+    switch (def.type) {
+      case 'number': {
+        const num = Number(value);
+        sanitized[key] = Number.isFinite(num)
+          ? num
+          : (hasExisting && Number.isFinite(ann[key]) ? Number(ann[key])
+            : (Number.isFinite(def.default_value) ? def.default_value : 0));
+        break;
+      }
+      case 'boolean':
+        sanitized[key] = value === 'false' ? false : Boolean(value);
+        break;
+      case 'options': {
+        const opts = Array.isArray(def.options) ? def.options : [];
+        const asString = value == null ? '' : String(value);
+        if (opts.includes(asString)) {
+          sanitized[key] = asString;
+        } else if (hasExisting && opts.includes(ann[key])) {
+          sanitized[key] = ann[key];
+        } else {
+          sanitized[key] = opts.includes(def.default_value) ? def.default_value : (opts[0] || '');
+        }
+        break;
+      }
+      case 'reference_selection': {
+        if (def.multiple) {
+          const arr = Array.isArray(value) ? value : (value ? [value] : []);
+          sanitized[key] = arr.map((v) => (v == null ? '' : String(v))).filter((s) => s.length);
+          if (!sanitized[key].length && hasExisting && Array.isArray(ann[key])) {
+            sanitized[key] = ann[key].slice();
+          }
+        } else {
+          sanitized[key] = value == null ? (hasExisting ? String(ann[key] ?? '') : '') : String(value);
+        }
+        break;
+      }
+      case 'textarea':
+      case 'string':
+        sanitized[key] = value == null ? (hasExisting ? String(ann[key] ?? '') : '') : String(value);
+        break;
+      case 'object':
+        sanitized[key] = (value && typeof value === 'object') ? __cloneValue(value) : __cloneValue(def.default_value);
+        break;
+      case 'transform':
+        sanitized[key] = normalizeTransform(value, def.default_value);
+        break;
+      case 'vec3':
+        sanitized[key] = normalizeVec3(value, def.default_value);
+        break;
+      default:
+        sanitized[key] = __cloneValue(value);
+        break;
+    }
+  }
+
+  return sanitized;
+}
+
+function normalizeTransform(value, fallback) {
+  const raw = value && typeof value === 'object' ? value : (fallback || {});
+  const toArray = (src, defaults, len = 3) => {
+    const arr = Array.isArray(src) ? src : (defaults && Array.isArray(defaults) ? defaults : []);
+    const out = [];
+    for (let i = 0; i < len; i += 1) {
+      const v = arr[i];
+      const n = Number(v);
+      out[i] = Number.isFinite(n) ? n : 0;
+    }
+    return out;
+  };
+  return {
+    position: toArray(raw.position, fallback?.position || [0, 0, 0]),
+    rotationEuler: toArray(raw.rotationEuler, fallback?.rotationEuler || [0, 0, 0]),
+    scale: toArray(raw.scale, fallback?.scale || [1, 1, 1]),
+  };
+}
+
+function normalizeVec3(value, fallback) {
+  const source = Array.isArray(value)
+    ? value
+    : (value && typeof value === 'object' ? [value.x, value.y, value.z] : fallback);
+  if (!Array.isArray(source)) return [0, 0, 0];
+  const out = [];
+  for (let i = 0; i < 3; i += 1) {
+    const n = Number(source[i]);
+    out[i] = Number.isFinite(n) ? n : 0;
+  }
+  return out;
+}
+
+function __cloneValue(value) {
+  if (value == null) return value;
+  if (Array.isArray(value)) return value.map((v) => __cloneValue(v));
+  if (typeof value === 'object') {
+    const out = {};
+    for (const k of Object.keys(value)) out[k] = __cloneValue(value[k]);
+    return out;
+  }
+  return value;
+}