@typemf/xmi 0.5.0

package/dist/index.cjs

@@ -0,0 +1,707 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  NamespaceCollector: () => NamespaceCollector,
+  XmiResourceFactory: () => XmiResourceFactory,
+  XmiSerializer: () => XmiSerializer,
+  allAttributesOf: () => allAttributesOf,
+  allStructuralFeaturesOf: () => allStructuralFeaturesOf,
+  computeEmfFragment: () => computeEmfFragment,
+  escapeAttributeValue: () => escapeAttributeValue,
+  escapeText: () => escapeText,
+  parseXmlDocument: () => parseXmlDocument,
+  registerXmiFormat: () => registerXmiFormat,
+  resolveEmfFragment: () => resolveEmfFragment
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/emf-fragment.ts
+function allStructuralFeaturesOf(eClass) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  function visit(c) {
+    if (seen.has(c)) return;
+    seen.add(c);
+    for (const parent of c.getESuperTypes()) visit(parent);
+    result.push(...c.getEStructuralFeatures());
+  }
+  visit(eClass);
+  return result;
+}
+function allAttributesOf(eClass) {
+  return allStructuralFeaturesOf(eClass).filter((f) => !("isContainment" in f));
+}
+function computeEmfFragment(target, roots) {
+  const idAttribute = allAttributesOf(target.eClass()).find((attr) => attr.isID());
+  if (idAttribute && target.eIsSet(idAttribute)) {
+    return String(target.eGet(idAttribute));
+  }
+  const segments = [];
+  let current = target;
+  let container = current.eContainer();
+  while (container) {
+    const feature = current.eContainingFeature();
+    if (!feature) {
+      throw new Error("Object has a container but no containing feature - inconsistent containment state.");
+    }
+    let segment = `@${feature.getName()}`;
+    if (feature.isMany()) {
+      const siblings = [...container.eGet(feature)];
+      const index = siblings.indexOf(current);
+      if (index === -1) {
+        throw new Error(`Object not found within its own containing feature '${feature.getName()}'.`);
+      }
+      segment += `.${index}`;
+    }
+    segments.unshift(segment);
+    current = container;
+    container = current.eContainer();
+  }
+  const rootIndex = roots.indexOf(current);
+  if (rootIndex === -1) {
+    throw new Error("Target object is not reachable from the given roots via containment.");
+  }
+  const path = segments.join("/");
+  if (roots.length === 1) {
+    return path === "" ? "/" : `//${path}`;
+  }
+  return path === "" ? `/${rootIndex}` : `/${rootIndex}/${path}`;
+}
+function resolveEmfFragment(fragment, roots) {
+  if (fragment === "/") {
+    return roots.length === 1 ? roots[0] : void 0;
+  }
+  if (fragment.startsWith("//")) {
+    const rest = fragment.slice(2);
+    if (roots.length !== 1) return void 0;
+    if (rest.startsWith("@")) {
+      return walkSegments(rest, roots[0]);
+    }
+    return walkNamedSegments(rest, roots[0]);
+  }
+  if (fragment.startsWith("/")) {
+    const rest = fragment.slice(1);
+    const slashIndex = rest.indexOf("/");
+    const rootIndexToken = slashIndex === -1 ? rest : rest.slice(0, slashIndex);
+    const rootIndex = Number(rootIndexToken);
+    if (!Number.isInteger(rootIndex) || rootIndex < 0 || rootIndex >= roots.length) return void 0;
+    const root = roots[rootIndex];
+    if (slashIndex === -1) return root;
+    return walkSegments(rest.slice(slashIndex + 1), root);
+  }
+  return findByIdValue(fragment, roots);
+}
+function walkNamedSegments(path, start) {
+  const segments = path.split("/");
+  let current = start;
+  for (const name of segments) {
+    if (!current) return void 0;
+    const currentClass = current.eClass();
+    const eClassifiersFeature = allStructuralFeaturesOf(currentClass).filter((feature) => feature.getName() === "eClassifiers").at(0);
+    if (eClassifiersFeature) {
+      current = findNamedChild(current, eClassifiersFeature, name);
+      continue;
+    }
+    const eStructuralFeaturesFeature = allStructuralFeaturesOf(currentClass).filter((feature) => feature.getName() === "eStructuralFeatures").at(0);
+    if (eStructuralFeaturesFeature) {
+      current = findNamedChild(current, eStructuralFeaturesFeature, name);
+      continue;
+    }
+    return void 0;
+  }
+  return current;
+}
+function findNamedChild(container, listFeature, name) {
+  const children = [...container.eGet(listFeature)];
+  return children.find((child) => {
+    const nameFeature = allStructuralFeaturesOf(child.eClass()).filter((feature) => feature.getName() === "name").at(0);
+    return nameFeature !== void 0 && child.eGet(nameFeature) === name;
+  });
+}
+function walkSegments(path, start) {
+  let current = start;
+  for (const segment of path.split("/")) {
+    if (!segment.startsWith("@")) return void 0;
+    const dotIndex = segment.indexOf(".");
+    const featureName = dotIndex === -1 ? segment.slice(1) : segment.slice(1, dotIndex);
+    const feature = allStructuralFeaturesOf(current.eClass()).filter((feature2) => feature2.getName() === featureName).at(0);
+    if (!feature) return void 0;
+    if (feature.isMany()) {
+      const indexToken = dotIndex === -1 ? void 0 : segment.slice(dotIndex + 1);
+      const index = Number(indexToken);
+      if (indexToken === void 0 || !Number.isInteger(index)) return void 0;
+      const list = [...current.eGet(feature)];
+      const next = list[index];
+      if (!next) return void 0;
+      current = next;
+    } else {
+      current = current.eGet(feature);
+    }
+  }
+  return current;
+}
+function findByIdValue(idValue, roots) {
+  for (const root of roots) {
+    const found = findByIdValueIn(root, idValue);
+    if (found) return found;
+  }
+  return void 0;
+}
+function findByIdValueIn(obj, idValue) {
+  const idAttribute = allAttributesOf(obj.eClass()).find((attr) => attr.isID());
+  if (idAttribute && obj.eIsSet(idAttribute) && String(obj.eGet(idAttribute)) === idValue) {
+    return obj;
+  }
+  for (const child of obj.eContents()) {
+    const found = findByIdValueIn(child, idValue);
+    if (found) return found;
+  }
+  return void 0;
+}
+
+// src/namespace-collector.ts
+var NamespaceCollector = class {
+  prefixToUri = /* @__PURE__ */ new Map();
+  uriToPrefix = /* @__PURE__ */ new Map();
+  prefixFor(pkg) {
+    const nsURI = pkg.getNsURI();
+    if (!nsURI) {
+      throw new Error(`EPackage '${pkg.getName()}' has no nsURI set - cannot serialize instances of it.`);
+    }
+    const existing = this.uriToPrefix.get(nsURI);
+    if (existing) return existing;
+    const base = pkg.getNsPrefix() || pkg.getName() || "ns";
+    let candidate = base;
+    let suffix = 0;
+    while (this.prefixToUri.has(candidate) && this.prefixToUri.get(candidate) !== nsURI) {
+      suffix += 1;
+      candidate = `${base}${suffix}`;
+    }
+    this.prefixToUri.set(candidate, nsURI);
+    this.uriToPrefix.set(nsURI, candidate);
+    return candidate;
+  }
+  entries() {
+    return [...this.prefixToUri.entries()];
+  }
+};
+
+// src/xmi-resource-factory.ts
+var import_core2 = require("@typemf/core");
+
+// src/xmi-serializer.ts
+var import_core = require("@typemf/core");
+
+// src/xml-text.ts
+function escapeAttributeValue(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/\r/g, "&#13;").replace(/\n/g, "&#10;").replace(/\t/g, "&#9;");
+}
+function escapeText(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/xml-dom.ts
+async function parseXmlDocument(text) {
+  const globalDOMParser = globalThis.DOMParser;
+  if (globalDOMParser) {
+    const doc2 = new globalDOMParser().parseFromString(text, "application/xml");
+    const parseError = doc2.getElementsByTagName("parsererror")[0];
+    if (parseError) {
+      throw new Error(`Failed to parse XML: ${parseError.textContent ?? "unknown parse error"}`);
+    }
+    return doc2;
+  }
+  const xmldom = await import("@xmldom/xmldom");
+  const errors = [];
+  const parser = new xmldom.DOMParser({
+    onError: (level, message) => {
+      if (level === "error" || level === "fatalError") errors.push(message);
+    }
+  });
+  const doc = parser.parseFromString(text, "application/xml");
+  if (errors.length > 0) {
+    throw new Error(`Failed to parse XML: ${errors.join("; ")}`);
+  }
+  return doc;
+}
+
+// src/xmi-serializer.ts
+var XMI_NS = "http://www.omg.org/XMI";
+var XSI_NS = "http://www.w3.org/2001/XMLSchema-instance";
+var XmiSerializer = class {
+  computeFragment(target, roots) {
+    return computeEmfFragment(target, roots);
+  }
+  resolveFragment(fragment, roots) {
+    return resolveEmfFragment(fragment, roots);
+  }
+  async serialize(roots, resource) {
+    if (roots.length !== 1) {
+      throw new Error(
+        `XmiSerializer currently only supports exactly one root object (got ${roots.length}) - multi-root documents need the <xmi:XMI> wrapper form, not yet implemented. See NOTES.md.`
+      );
+    }
+    const root = roots[0];
+    const namespaces = new NamespaceCollector();
+    const rootPrefix = namespaces.prefixFor(requirePackage(root.eClass()));
+    const parts = writeObjectParts(root, `${rootPrefix}:${root.eClass().getName()}`, roots, resource, namespaces);
+    const nsAttrs = [
+      ["xmlns:xmi", XMI_NS],
+      ["xmlns:xsi", XSI_NS],
+      ...namespaces.entries().map(([prefix, uri]) => [`xmlns:${prefix}`, uri])
+    ];
+    const schemaLocationAttrs = [];
+    const rootPackage = requirePackage(root.eClass());
+    const rootPackageResource = (0, import_core.getResourceOf)(rootPackage);
+    if (rootPackageResource && rootPackageResource !== resource) {
+      const location = relativeOrAbsolutePath(resource.getURI(), rootPackageResource.getURI());
+      schemaLocationAttrs.push(["xsi:schemaLocation", `${rootPackage.getNsURI()} ${location}`]);
+    }
+    const allAttrs = [
+      ["xmi:version", "2.0"],
+      ...nsAttrs,
+      ...schemaLocationAttrs,
+      ...parts.attributes
+    ];
+    const attrStr = allAttrs.map(([k, v]) => ` ${k}="${escapeAttributeValue(v)}"`).join("");
+    const xml = `<?xml version="1.0" encoding="UTF-8"?>
+` + (parts.childrenXml ? `<${parts.tagName}${attrStr}>${parts.childrenXml}</${parts.tagName}>` : `<${parts.tagName}${attrStr}/>`);
+    return new TextEncoder().encode(xml);
+  }
+  /**
+   * Root-element only (not a full-tree walk), all declared xmlns:* values (not filtered to ones
+   * some xsi:type actually uses) - the simpler of the two real tradeoffs this method has for XMI,
+   * chosen deliberately: this project's own writer always declares every namespace a document
+   * needs on the root element (see NamespaceCollector/the ['xmlns:xmi', ...] block above), so this
+   * is exactly correct for anything this project produces. A third-party or hand-edited XMI file
+   * that declares a namespace deeper in the tree (legal XML, just non-standard practice for this
+   * kind of document) would have that namespace missed here - an accepted, documented limitation,
+   * not an oversight.
+   */
+  async peekReferencedNsURIs(content) {
+    const text = new TextDecoder().decode(content);
+    const doc = await parseXmlDocument(text);
+    const root = doc.documentElement;
+    if (!root) return [];
+    const nsURIs = [];
+    for (const attr of Array.from(root.attributes)) {
+      if (!attr.name.startsWith("xmlns:")) continue;
+      if (attr.value === XMI_NS || attr.value === XSI_NS) continue;
+      nsURIs.push(attr.value);
+    }
+    return nsURIs;
+  }
+  async deserialize(content, resource) {
+    const text = new TextDecoder().decode(content);
+    const doc = await parseXmlDocument(text);
+    const root = doc.documentElement;
+    if (!root) {
+      throw new Error(`'${resource.getURI().toString()}' has no document element - not a valid XML document.`);
+    }
+    const packageRegistry = resource.getResourceSet()?.getPackageRegistry();
+    if (!packageRegistry) {
+      throw new Error(
+        `Cannot deserialize '${resource.getURI().toString()}': its Resource has no ResourceSet, which is needed to look up EPackages by namespace URI.`
+      );
+    }
+    const ctx = { packageRegistry };
+    const elementToObj = /* @__PURE__ */ new Map();
+    const rootEClass = resolveElementEClass(root, packageRegistry);
+    const rootObj = constructShell(root, rootEClass, ctx, elementToObj);
+    const roots = [rootObj];
+    completeObject(root, rootObj, ctx, elementToObj, roots);
+    return roots;
+  }
+};
+function writeObjectParts(obj, tagName, roots, sourceResource, namespaces) {
+  const attributes = [];
+  let childrenXml = "";
+  for (const feature of obj.eClass().getEAllStructuralFeatures()) {
+    if (feature.isDerived() || feature.isTransient()) continue;
+    if (!obj.eIsSet(feature)) continue;
+    if (!isReferenceFeature(feature)) {
+      if (feature.isMany()) {
+        for (const value of obj.eGet(feature)) {
+          childrenXml += `<${feature.getName()}>${escapeText(encodeAttributeValue(value, feature))}</${feature.getName()}>`;
+        }
+      } else {
+        attributes.push([feature.getName(), encodeAttributeValue(obj.eGet(feature), feature)]);
+      }
+      continue;
+    }
+    const refFeature = feature;
+    const values = refFeature.isMany() ? [...obj.eGet(feature)] : [obj.eGet(feature)];
+    if (refFeature.isContainment()) {
+      for (const child of values) {
+        const childTag = childElementTag(child, refFeature, namespaces);
+        const childParts = writeObjectParts(child, feature.getName(), roots, sourceResource, namespaces);
+        const attrs = childTag.xsiType ? [["xsi:type", childTag.xsiType], ...childParts.attributes] : childParts.attributes;
+        childrenXml += renderElement({
+          tagName: childParts.tagName,
+          attributes: attrs,
+          childrenXml: childParts.childrenXml
+        });
+      }
+      continue;
+    }
+    const encoded = values.map((v) => encodeReferenceValue(v, refFeature, roots, sourceResource, namespaces));
+    const anyCrossDocument = encoded.some((e) => e.crossDocument);
+    if (anyCrossDocument) {
+      for (const e of encoded) {
+        const attrs = [["href", e.value]];
+        if (e.xsiType) attrs.unshift(["xsi:type", e.xsiType]);
+        childrenXml += renderElement({ tagName: feature.getName(), attributes: attrs, childrenXml: "" });
+      }
+    } else {
+      const anyPolymorphic = encoded.some((e) => e.xsiType);
+      const tokens = encoded.map(
+        (e) => anyPolymorphic ? `${e.xsiType ?? sameTypeToken(refFeature, namespaces)} ${e.value}` : e.value
+      );
+      attributes.push([feature.getName(), tokens.join(" ")]);
+    }
+  }
+  return { tagName, attributes, childrenXml };
+}
+function renderElement(parts) {
+  const attrStr = parts.attributes.map(([k, v]) => ` ${k}="${escapeAttributeValue(v)}"`).join("");
+  return parts.childrenXml ? `<${parts.tagName}${attrStr}>${parts.childrenXml}</${parts.tagName}>` : `<${parts.tagName}${attrStr}/>`;
+}
+function childElementTag(child, feature, namespaces) {
+  const declared = feature.getEType();
+  const actual = child.eClass();
+  if (declared === actual) return {};
+  const prefix = namespaces.prefixFor(requirePackage(actual));
+  return { xsiType: `${prefix}:${actual.getName()}` };
+}
+function sameTypeToken(feature, namespaces) {
+  const declared = feature.getEType();
+  const prefix = namespaces.prefixFor(requirePackage(declared));
+  return `${prefix}:${declared.getName()}`;
+}
+function encodeReferenceValue(target, feature, roots, sourceResource, namespaces) {
+  const declared = feature.getEType();
+  if (target.eIsProxy()) {
+    const proxy = target;
+    const actual2 = proxy.eClass();
+    const xsiType2 = declared !== actual2 ? `${namespaces.prefixFor(requirePackage(actual2))}:${actual2.getName()}` : void 0;
+    return { value: proxy.getProxyURI().toString(), crossDocument: true, xsiType: xsiType2 };
+  }
+  const targetResource = (0, import_core.getResourceOf)(target);
+  const actual = target.eClass();
+  const xsiType = declared !== actual ? `${namespaces.prefixFor(requirePackage(actual))}:${actual.getName()}` : void 0;
+  if (isReachableFromRoots(target, roots)) {
+    return { value: fragmentForTarget(target, targetResource, roots), crossDocument: false, xsiType };
+  }
+  const ecoreOwnPath = ecoreOwnFragmentPath(target);
+  if (ecoreOwnPath !== void 0) {
+    return { value: `${import_core.EcorePackageImpl.eINSTANCE.getNsURI()}#${ecoreOwnPath}`, crossDocument: true, xsiType };
+  }
+  if (targetResource) {
+    return {
+      value: `${targetResource.getURI().toString()}#${fragmentForTarget(target, targetResource, roots)}`,
+      crossDocument: true,
+      xsiType
+    };
+  }
+  throw new Error(
+    `Cannot encode a reference to an object of class '${actual.getName()}': it has no resource of its own, is not part of Ecore's own metamodel, and is not reachable from this document's own roots via containment.`
+  );
+}
+function isReachableFromRoots(target, roots) {
+  let current = target;
+  while (current) {
+    if (roots.includes(current)) return true;
+    current = current.eContainer();
+  }
+  return false;
+}
+function ecoreOwnFragmentPath(target) {
+  const ecore = import_core.EcorePackageImpl.eINSTANCE;
+  if ((0, import_core.isEClassifier)(target)) {
+    return target.getEPackage() === ecore ? `//${target.getName() ?? ""}` : void 0;
+  }
+  const containingClass = hasContainingClass(target) ? target.getEContainingClass() : void 0;
+  if (containingClass && containingClass.getEPackage() === ecore && isNamed(target)) {
+    return `//${containingClass.getName() ?? ""}/${target.getName() ?? ""}`;
+  }
+  return void 0;
+}
+function hasContainingClass(obj) {
+  return typeof obj.getEContainingClass === "function";
+}
+function isNamed(obj) {
+  return typeof obj.getName === "function";
+}
+function fragmentForTarget(target, owningResource, fallbackRoots) {
+  if (!owningResource) return computeEmfFragment(target, fallbackRoots);
+  const roots = owningResource.getContents().toArray();
+  const serializer = owningResource.getSerializer();
+  return serializer.computeFragment ? serializer.computeFragment(target, roots) : (0, import_core.computeFragment)(target, roots);
+}
+function isReferenceFeature(feature) {
+  return "isContainment" in feature;
+}
+function requirePackage(eClass) {
+  const pkg = eClass.getEPackage();
+  if (!pkg) throw new Error(`EClass '${eClass.getName()}' has no owning EPackage - cannot serialize instances of it.`);
+  return pkg;
+}
+function encodeAttributeValue(value, feature) {
+  const eType = feature.getEType();
+  if (eType?.getName() === "EDate" && value instanceof Date) {
+    return value.toISOString();
+  }
+  return String(value);
+}
+function resolveElementEClass(element, packageRegistry) {
+  const xsiType = element.getAttributeNS(XSI_NS, "type");
+  if (xsiType) {
+    return resolvePrefixedName(xsiType, element, packageRegistry);
+  }
+  const nsURI = element.namespaceURI;
+  if (!nsURI) {
+    throw new Error(`Element <${element.tagName}> has no namespace - cannot determine its EPackage.`);
+  }
+  const pkg = packageRegistry.getPackage(nsURI);
+  if (!pkg) {
+    throw new Error(`No EPackage registered for namespace '${nsURI}' (element <${element.tagName}>).`);
+  }
+  const classifier = pkg.getEClassifier(element.localName);
+  if (!classifier) {
+    throw new Error(`Package '${nsURI}' has no classifier named '${element.localName}'.`);
+  }
+  return classifier;
+}
+function resolveContainmentChildEClass(element, declared, packageRegistry) {
+  const xsiType = element.getAttributeNS(XSI_NS, "type");
+  if (xsiType) return resolvePrefixedName(xsiType, element, packageRegistry);
+  return declared;
+}
+function resolvePrefixedName(token, contextElement, packageRegistry) {
+  const [prefix, name] = token.includes(":") ? token.split(":") : [void 0, token];
+  const nsURI = prefix ? contextElement.lookupNamespaceURI(prefix) : contextElement.namespaceURI;
+  if (!nsURI) {
+    throw new Error(`Could not resolve namespace prefix '${prefix ?? "<default>"}' for type token '${token}'.`);
+  }
+  const pkg = packageRegistry.getPackage(nsURI);
+  if (!pkg) {
+    throw new Error(`No EPackage registered for namespace '${nsURI}' (type token '${token}').`);
+  }
+  const classifier = pkg.getEClassifier(name);
+  if (!classifier) {
+    throw new Error(`Package '${nsURI}' has no classifier named '${name}'.`);
+  }
+  return classifier;
+}
+function constructShell(element, eClass, ctx, elementToObj) {
+  const obj = eClass.getEPackage()?.getEFactoryInstance()?.create(eClass);
+  if (!obj) throw new Error("Could not create object");
+  elementToObj.set(element, obj);
+  const nameFeature = allStructuralFeaturesOf(eClass).filter((f) => f.getName() === "name").at(0);
+  if (nameFeature) {
+    const nameAttrValue = element.getAttribute("name");
+    if (nameAttrValue !== null) {
+      obj.eSet(nameFeature, decodeAttributeValue(nameAttrValue, nameFeature));
+    }
+  }
+  const idFeature = eClass.getEIDAttribute();
+  const idFeatureName = idFeature?.getName();
+  if (idFeature && idFeatureName && idFeature !== nameFeature) {
+    const idAttrValue = element.getAttribute(idFeatureName);
+    if (idAttrValue !== null) {
+      obj.eSet(idFeature, decodeAttributeValue(idAttrValue, idFeature));
+    }
+  }
+  for (let i = 0; i < element.childNodes.length; i++) {
+    const node = element.childNodes.item(i);
+    if (!node || node.nodeType !== 1) continue;
+    const child = node;
+    const feature = allStructuralFeaturesOf(eClass).filter((feature2) => feature2.getName() === child.localName).at(0);
+    if (!feature || !isReferenceFeature(feature)) continue;
+    const refFeature = feature;
+    if (!refFeature.isContainment()) continue;
+    const declaredEClass = refFeature.getEType();
+    const childEClass = resolveContainmentChildEClass(child, declaredEClass, ctx.packageRegistry);
+    const childObj = constructShell(child, childEClass, ctx, elementToObj);
+    if (feature.isMany()) {
+      const list = obj.eGet(feature);
+      list.add(childObj);
+    } else {
+      obj.eSet(feature, childObj);
+    }
+  }
+  return obj;
+}
+function completeObject(element, obj, ctx, elementToObj, roots) {
+  const eClass = obj.eClass();
+  for (let i = 0; i < element.attributes.length; i++) {
+    const attr = element.attributes.item(i);
+    if (attr.namespaceURI === XMI_NS || attr.namespaceURI === XSI_NS) continue;
+    if (attr.name.startsWith("xmlns")) continue;
+    const feature = allStructuralFeaturesOf(eClass).filter((feature2) => feature2.getName() === attr.localName).at(0);
+    if (!feature) continue;
+    if (!isReferenceFeature(feature)) {
+      if (feature.isMany()) {
+        continue;
+      }
+      obj.eSet(feature, decodeAttributeValue(attr.value, feature));
+      continue;
+    }
+    const refFeature = feature;
+    const resolved = decodeAttributeFormReference(attr.value, refFeature, element, roots, ctx.packageRegistry);
+    if (refFeature.isMany()) {
+      const list = obj.eGet(refFeature);
+      for (const r of resolved) list.add(r);
+    } else {
+      obj.eSet(refFeature, resolved[0]);
+    }
+  }
+  for (let i = 0; i < element.childNodes.length; i++) {
+    const node = element.childNodes.item(i);
+    if (!node || node.nodeType !== 1) continue;
+    const child = node;
+    const feature = allStructuralFeaturesOf(eClass).filter((feature2) => feature2.getName() === child.localName).at(0);
+    if (!feature) continue;
+    if (!isReferenceFeature(feature)) {
+      const value = decodeAttributeValue(child.textContent ?? "", feature);
+      if (feature.isMany()) {
+        const list = obj.eGet(feature);
+        list.add(value);
+      } else {
+        obj.eSet(feature, value);
+      }
+      continue;
+    }
+    const refFeature = feature;
+    if (refFeature.isContainment()) {
+      const childObj = elementToObj.get(child);
+      if (!childObj) {
+        throw new Error(
+          `Internal error: no shell was constructed for <${child.tagName}> during pass 1 - constructShell and completeObject have diverged on which children count as containment.`
+        );
+      }
+      completeObject(child, childObj, ctx, elementToObj, roots);
+      continue;
+    }
+    const href = child.getAttribute("href");
+    if (!href) {
+      throw new Error(`<${child.tagName}> under <${element.tagName}> is a non-containment reference but has no href.`);
+    }
+    const xsiType = child.getAttributeNS(XSI_NS, "type");
+    const declared = refFeature.getEType();
+    const proxyEClass = xsiType ? resolvePrefixedName(xsiType, child, ctx.packageRegistry) : declared;
+    const proxy = new import_core.ProxyEObjectImpl(proxyEClass, import_core.URI.parse(href));
+    if (feature.isMany()) {
+      const list = obj.eGet(feature);
+      list.add(proxy);
+    } else {
+      obj.eSet(feature, proxy);
+    }
+  }
+}
+function decodeAttributeFormReference(rawValue, feature, contextElement, roots, packageRegistry) {
+  const tokens = rawValue.split(/\s+/).filter((t) => t.length > 0);
+  const paired = tokens.length > 0 && tokens.length % 2 === 0 && tokens.every((t, i) => i % 2 === 0 ? looksLikeTypeToken(t) : true);
+  const pairs = paired ? tokens.filter((_, i) => i % 2 === 1).map((fragment, i) => ({ typeToken: tokens[i * 2], fragment })) : tokens.map((fragment) => ({ typeToken: void 0, fragment }));
+  return pairs.map(({ typeToken, fragment }) => {
+    if (isAbsoluteUri(fragment)) {
+      const declared = feature.getEType();
+      const proxyEClass = typeToken ? resolvePrefixedName(typeToken, contextElement, packageRegistry) : declared;
+      return new import_core.ProxyEObjectImpl(proxyEClass, import_core.URI.parse(fragment));
+    }
+    const normalized = fragment.startsWith("#") ? fragment.slice(1) : fragment;
+    const resolved = resolveEmfFragment(normalized, roots);
+    if (!resolved) {
+      throw new Error(
+        `Unresolved same-document reference '${fragment}' on feature '${feature.getName()}': no object matches this fragment in this document.`
+      );
+    }
+    return resolved;
+  });
+}
+function relativeOrAbsolutePath(fromUri, toUri) {
+  if (fromUri.getScheme() !== toUri.getScheme()) return toUri.toString();
+  const fromSegments = fromUri.getPath().split("/").filter((s) => s.length > 0);
+  const toSegments = toUri.getPath().split("/").filter((s) => s.length > 0);
+  const fromDir = fromSegments.slice(0, -1);
+  const toDir = toSegments.slice(0, -1);
+  const toFile = toSegments[toSegments.length - 1] ?? "";
+  let commonLength = 0;
+  while (commonLength < fromDir.length && commonLength < toDir.length && fromDir[commonLength] === toDir[commonLength]) {
+    commonLength++;
+  }
+  const upSegments = fromDir.slice(commonLength).map(() => "..");
+  const downSegments = toDir.slice(commonLength);
+  const relativeSegments = [...upSegments, ...downSegments, toFile];
+  return relativeSegments.join("/");
+}
+function looksLikeTypeToken(token) {
+  return token.includes(":") && !token.startsWith("/") && !token.startsWith("#");
+}
+function isAbsoluteUri(token) {
+  return /^[a-zA-Z][a-zA-Z0-9+.-]*:(\/\/|#)/.test(token);
+}
+function decodeAttributeValue(value, feature) {
+  const eType = feature.getEType();
+  const typeName = eType?.getName();
+  if (typeName === "EDate") return new Date(value);
+  if (typeName === "EInt" || typeName === "ELong" || typeName === "EDouble" || typeName === "EFloat")
+    return Number(value);
+  if (typeName === "EBoolean") return value === "true";
+  return value;
+}
+
+// src/xmi-resource-factory.ts
+var XmiResourceFactory = class {
+  createResource(uri) {
+    return new import_core2.ResourceImpl(uri, new XmiSerializer());
+  }
+};
+function registerXmiFormat(registry) {
+  registry.registerForExtension("xmi", new XmiResourceFactory());
+  registry.registerForExtension("ecore", new XmiResourceFactory());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  NamespaceCollector,
+  XmiResourceFactory,
+  XmiSerializer,
+  allAttributesOf,
+  allStructuralFeaturesOf,
+  computeEmfFragment,
+  escapeAttributeValue,
+  escapeText,
+  parseXmlDocument,
+  registerXmiFormat,
+  resolveEmfFragment
+});
+//# sourceMappingURL=index.cjs.map