@citolab/qti-components 7.28.0 → 8.0.0

package/dist/chunk-IJD53WY6.js

@@ -0,0 +1,719 @@
+// ../qti-transformers/dist/item/cdata.js
+function convertCDATAtoComment(xmlFragment) {
+  const cdataElements = xmlFragment.querySelectorAll('qti-custom-operator[class="js.org"] > qti-base-value');
+  cdataElements.forEach((element) => {
+    const commentText = document.createComment(element.textContent);
+    element.replaceChild(commentText, element.firstChild);
+  });
+}
+
+// ../qti-transformers/dist/item/configure-pci.js
+async function configurePci(xmlFragment, baseUrl, getModuleResolutionConfig, selector = "qti-portable-custom-interaction") {
+  const customInteractionTypeIdentifiers = [];
+  const portableCustomInteractions = xmlFragment.querySelectorAll(selector);
+  if (portableCustomInteractions.length === 0) {
+    return;
+  }
+  let moduleResolutionConfig = null;
+  let moduleResolutionFallbackConfig = null;
+  const ensureDefaultModuleResolutionConfigs = async () => {
+    if (moduleResolutionConfig === null) {
+      try {
+        moduleResolutionConfig = await getModuleResolutionConfig(baseUrl, "/modules/module_resolution.js");
+      } catch {
+        moduleResolutionConfig = null;
+      }
+    }
+    if (moduleResolutionFallbackConfig === null) {
+      try {
+        moduleResolutionFallbackConfig = await getModuleResolutionConfig(baseUrl, "/modules/fallback_module_resolution.js");
+      } catch {
+        moduleResolutionFallbackConfig = null;
+      }
+    }
+  };
+  for (const interaction of Array.from(portableCustomInteractions)) {
+    interaction.setAttribute("data-base-url", baseUrl);
+    let customInteractionTypeIdentifier = interaction.getAttribute("custom-interaction-type-identifier");
+    if (customInteractionTypeIdentifier && customInteractionTypeIdentifiers.includes(customInteractionTypeIdentifier)) {
+      customInteractionTypeIdentifier = customInteractionTypeIdentifier + customInteractionTypeIdentifiers.length;
+      interaction.setAttribute("custom-interaction-type-identifier", customInteractionTypeIdentifier);
+      customInteractionTypeIdentifiers.push(customInteractionTypeIdentifier);
+    }
+    if (customInteractionTypeIdentifier) {
+      customInteractionTypeIdentifiers.push(customInteractionTypeIdentifier);
+    }
+    let modulesElement = interaction.querySelector("qti-interaction-modules");
+    if (modulesElement && modulesElement.getAttribute("primary-configuration")) {
+      await ensureDefaultModuleResolutionConfigs();
+      const primaryConfigPath = modulesElement.getAttribute("primary-configuration");
+      if (primaryConfigPath) {
+        try {
+          const primaryConfig = await getModuleResolutionConfig(baseUrl, `/${primaryConfigPath}`);
+          const existingModules = Array.from(modulesElement.querySelectorAll("qti-interaction-module"));
+          for (const moduleEl of existingModules) {
+            const moduleId = moduleEl.getAttribute("id");
+            if (moduleId && primaryConfig.paths && primaryConfig.paths[moduleId]) {
+              const primaryPath = primaryConfig.paths[moduleId];
+              const primaryPathString = Array.isArray(primaryPath) ? primaryPath[0] : primaryPath;
+              moduleEl.setAttribute("primary-path", primaryPathString);
+              if (moduleResolutionFallbackConfig && moduleResolutionFallbackConfig.paths && moduleResolutionFallbackConfig.paths[moduleId]) {
+                const fallbackPath = moduleResolutionFallbackConfig.paths[moduleId];
+                if (Array.isArray(fallbackPath)) {
+                  moduleEl.setAttribute("fallback-path", fallbackPath[0]);
+                } else {
+                  moduleEl.setAttribute("fallback-path", fallbackPath);
+                }
+              }
+            }
+          }
+          if (primaryConfig.paths) {
+            for (const moduleId in primaryConfig.paths) {
+              const existingModule = modulesElement.querySelector(`qti-interaction-module[id="${moduleId}"]`);
+              if (!existingModule) {
+                const newModuleElement = xmlFragment.createElement("qti-interaction-module");
+                newModuleElement.setAttribute("id", moduleId);
+                const primaryPathString = Array.isArray(primaryConfig.paths[moduleId]) ? primaryConfig.paths[moduleId][0] : primaryConfig.paths[moduleId];
+                newModuleElement.setAttribute("primary-path", primaryPathString);
+                if (moduleResolutionFallbackConfig && moduleResolutionFallbackConfig.paths && moduleResolutionFallbackConfig.paths[moduleId]) {
+                  const fallbackPath = moduleResolutionFallbackConfig.paths[moduleId];
+                  if (Array.isArray(fallbackPath)) {
+                    newModuleElement.setAttribute("fallback-path", fallbackPath[0]);
+                  } else {
+                    newModuleElement.setAttribute("fallback-path", fallbackPath);
+                  }
+                }
+                modulesElement.appendChild(newModuleElement);
+              }
+            }
+          }
+          if (primaryConfig.urlArgs) {
+            modulesElement.setAttribute("url-args", primaryConfig.urlArgs);
+          }
+        } catch (error) {
+          console.warn(`Failed to load primary configuration: ${primaryConfigPath}`, error);
+        }
+      }
+    } else {
+      await ensureDefaultModuleResolutionConfigs();
+      if (moduleResolutionConfig) {
+        if (interaction.querySelector("qti-interaction-modules") === null) {
+          modulesElement = xmlFragment.createElement("qti-interaction-modules");
+          interaction.appendChild(modulesElement);
+        } else {
+          modulesElement = interaction.querySelector("qti-interaction-modules");
+        }
+        for (const module in moduleResolutionConfig.paths) {
+          const path = moduleResolutionConfig.paths[module];
+          let fallbackPath = "";
+          if (moduleResolutionFallbackConfig && moduleResolutionFallbackConfig.paths && moduleResolutionFallbackConfig.paths[module]) {
+            fallbackPath = moduleResolutionFallbackConfig.paths[module];
+          }
+          const primaryArray = Array.isArray(path) ? path : [path];
+          const fallbackPathArray = Array.isArray(fallbackPath) ? fallbackPath : [fallbackPath];
+          const paths = primaryArray.map((primaryPath, i) => {
+            const fallbackPath2 = fallbackPathArray.length > i ? fallbackPathArray[i] : "";
+            return {
+              primaryPath,
+              fallbackPath: fallbackPath2
+            };
+          });
+          for (const fallbackPath2 of fallbackPathArray) {
+            if (!paths.some((p) => p.fallbackPath === fallbackPath2)) {
+              paths.push({
+                primaryPath: primaryArray.length > 0 ? primaryArray[0] : fallbackPath2,
+                fallbackPath: fallbackPath2
+              });
+            }
+          }
+          for (const path2 of paths) {
+            const moduleElement = xmlFragment.createElement("qti-interaction-module");
+            if (path2.fallbackPath) {
+              moduleElement.setAttribute("fallback-path", path2.fallbackPath);
+            }
+            moduleElement.setAttribute("id", module);
+            moduleElement.setAttribute("primary-path", path2.primaryPath);
+            if (modulesElement) {
+              modulesElement.appendChild(moduleElement);
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+// ../qti-transformers/dist/item/extend.js
+function extendElementName(xmlFragment, tagName, extension) {
+  const allElements = Array.from(xmlFragment.getElementsByTagName("*"));
+  const matchingElements = allElements.filter((element) => element.localName === tagName || element.localName?.toLowerCase() === tagName.toLowerCase());
+  matchingElements.forEach((element) => {
+    const newTagName = `${tagName}-${extension}`;
+    const newElement = createElementWithNewTagName(element, newTagName);
+    element.replaceWith(newElement);
+  });
+}
+function extendElementsWithClass(xmlFragment, classNamePattern) {
+  xmlFragment.querySelectorAll("*").forEach((element) => {
+    const classList = element.classList;
+    if (classList) {
+      classList.forEach((className) => {
+        if (className.startsWith(`${classNamePattern}:`)) {
+          const suffix = className.slice(`${classNamePattern}:`.length);
+          const newTagName = `${element.nodeName}-${suffix}`;
+          const newElement = createElementWithNewTagName(element, newTagName);
+          element.replaceWith(newElement);
+        }
+      });
+    }
+  });
+}
+function createElementWithNewTagName(element, newTagName) {
+  const newElement = element.ownerDocument.createElement(newTagName);
+  for (const attr of element.attributes) {
+    newElement.setAttribute(attr.name, attr.value);
+  }
+  while (element.firstChild) {
+    newElement.appendChild(element.firstChild);
+  }
+  return newElement;
+}
+
+// ../qti-transformers/dist/item/pci-hooks.js
+function pciHooks(xmlFragment, uri) {
+  const attributes = ["hook", "module"];
+  const documentPath = uri.substring(0, uri.lastIndexOf("/"));
+  for (const attribute of attributes) {
+    const srcAttributes = xmlFragment.querySelectorAll("[" + attribute + "]");
+    srcAttributes.forEach((node) => {
+      const srcValue = node.getAttribute(attribute);
+      if (!srcValue.startsWith("data:") && !srcValue.startsWith("http")) {
+        node.setAttribute("base-url", uri);
+        node.setAttribute("module", documentPath + "/" + encodeURI(srcValue + (srcValue.endsWith(".js") ? "" : ".js")));
+      }
+    });
+  }
+}
+
+// ../qti-transformers/dist/shared/prng.js
+var SeededRandom = class _SeededRandom {
+  #state;
+  constructor(seed) {
+    if (!(seed instanceof Uint8Array)) {
+      throw new TypeError("SeededRandom seed must be a Uint8Array.");
+    }
+    if (seed.length > 32) {
+      throw new RangeError("SeededRandom seed must be 32 bytes or less.");
+    }
+    const paddedSeed = new Uint8Array(32);
+    paddedSeed.set(seed, 32 - seed.length);
+    this.#state = hashBytes(paddedSeed);
+  }
+  static fromSeed(seed) {
+    if (seed.length !== 32) {
+      throw new RangeError("SeededRandom.fromSeed requires a 32-byte seed.");
+    }
+    return new _SeededRandom(seed);
+  }
+  static fromFixed(byte) {
+    if (typeof byte !== "number") {
+      throw new TypeError("SeededRandom.fromFixed requires a number.");
+    }
+    if (!Number.isInteger(byte) || byte < 0 || byte > 255) {
+      throw new RangeError("SeededRandom.fromFixed requires an integer from 0 to 255.");
+    }
+    const seed = new Uint8Array(32);
+    seed[31] = byte;
+    return new _SeededRandom(seed);
+  }
+  static fromSeedKey(seedKey) {
+    const random = new _SeededRandom(new Uint8Array());
+    random.#state = hashString(`${seedKey}`);
+    return random;
+  }
+  random() {
+    this.#state |= 0;
+    this.#state = this.#state + 1831565813 | 0;
+    let t = Math.imul(this.#state ^ this.#state >>> 15, 1 | this.#state);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+};
+function createSeededRandom(seedKey) {
+  return SeededRandom.fromSeedKey(seedKey);
+}
+function hashString(seedKey) {
+  let h = 1779033703 ^ seedKey.length;
+  for (let i = 0; i < seedKey.length; i++) {
+    h = Math.imul(h ^ seedKey.charCodeAt(i), 3432918353);
+    h = h << 13 | h >>> 19;
+  }
+  return finalizeHash(h);
+}
+function hashBytes(seed) {
+  let h = 1779033703 ^ seed.length;
+  for (let i = 0; i < seed.length; i++) {
+    h = Math.imul(h ^ seed[i], 3432918353);
+    h = h << 13 | h >>> 19;
+  }
+  return finalizeHash(h);
+}
+function finalizeHash(hash) {
+  let h = Math.imul(hash ^ hash >>> 16, 2246822507);
+  h = Math.imul(h ^ h >>> 13, 3266489909);
+  return (h ^ h >>> 16) >>> 0;
+}
+
+// ../qti-transformers/dist/shared/shuffle.js
+var randomValue = (source) => typeof source === "function" ? source() : source.random();
+function shuffleKeepingFixed(units, random) {
+  const movable = units.filter((unit) => !unit.fixed);
+  for (let i = movable.length - 1; i > 0; i--) {
+    const j = Math.floor(randomValue(random) * (i + 1));
+    [movable[i], movable[j]] = [movable[j], movable[i]];
+  }
+  let movableIndex = 0;
+  return units.map((unit) => unit.fixed ? unit : movable[movableIndex++]);
+}
+
+// ../qti-transformers/dist/item/shuffle-interactions.js
+function getShuffleQuerySelectorByTagName(tagName) {
+  switch (tagName) {
+    case "qti-choice-interaction":
+    case "qti-order-interaction":
+      return "qti-simple-choice";
+    case "qti-inline-choice-interaction":
+      return "qti-inline-choice";
+    case "qti-match-interaction":
+      return [
+        "qti-simple-match-set:first-of-type qti-simple-associable-choice",
+        "qti-simple-match-set:last-of-type > qti-simple-associable-choice"
+      ];
+    case "qti-gap-match-interaction":
+      return "qti-gap-text";
+    case "qti-associate-interaction":
+      return "qti-simple-associable-choice";
+    default:
+      return null;
+  }
+}
+function shuffleInteractions(xmlFragment, seed) {
+  const shuffleElements = xmlFragment.querySelectorAll(`[shuffle="true"]`);
+  const shuffleInteractions2 = Array.from(shuffleElements).filter((e) => e.tagName?.toLowerCase().endsWith("-interaction"));
+  const seeded = seed != null && `${seed}`.length > 0;
+  const itemId = xmlFragment.querySelector?.("qti-assessment-item")?.getAttribute("identifier") ?? "";
+  let interactionIndex = 0;
+  for (const shuffleInteraction of shuffleInteractions2) {
+    const responseId = shuffleInteraction.getAttribute("response-identifier") ?? `${interactionIndex}`;
+    interactionIndex++;
+    const query = getShuffleQuerySelectorByTagName(shuffleInteraction.tagName.toLowerCase());
+    const queries = Array.isArray(query) ? query : [query];
+    let shuffledAny = false;
+    let queryIndex = 0;
+    for (const q of queries) {
+      if (!q)
+        continue;
+      const random = seeded ? createSeededRandom(`${seed}:${itemId}:${responseId}:${queryIndex}`) : Math.random;
+      queryIndex++;
+      const choices = Array.from(shuffleInteraction.querySelectorAll(q)).filter((choice) => choice.parentElement !== null);
+      if (choices.filter((choice) => choice.getAttribute("fixed") !== "true").length <= 1) {
+        console.warn("Shuffling is not possible with fewer than 2 non-fixed elements.");
+        continue;
+      }
+      const parent = choices[0].parentElement;
+      if (!parent || choices.some((choice) => choice.parentElement !== parent)) {
+        console.warn("Shuffling is not possible when choices do not share the same parent element.");
+        continue;
+      }
+      const anchor = choices[choices.length - 1].nextSibling;
+      const orderedChoices = shuffleKeepingFixed(choices.map((choice) => ({
+        element: choice,
+        fixed: choice.getAttribute("fixed") === "true"
+      })), random);
+      for (const choice of choices) {
+        choice.remove();
+      }
+      for (const { element } of orderedChoices) {
+        parent.insertBefore(element, anchor);
+      }
+      shuffledAny = true;
+    }
+    if (shuffledAny) {
+      shuffleInteraction.removeAttribute("shuffle");
+    }
+  }
+}
+
+// ../qti-transformers/dist/item/stylesheets.js
+function stripStyleSheets(xmlFragment) {
+  xmlFragment.querySelectorAll("qti-stylesheet").forEach((stylesheet) => stylesheet.remove());
+}
+
+// ../qti-transformers/dist/shared/missing-seed-warning.js
+var missingSeedWarned = false;
+function warnMissingSeed(scope, fallbackSeed) {
+  if (missingSeedWarned)
+    return;
+  missingSeedWarned = true;
+  console.warn(`[${scope}] No QTI_CONTEXT.seed provided; using "${fallbackSeed}" as deterministic fallback seed.`);
+}
+
+// ../qti-transformers/dist/shared/xml.js
+function loadXML(url, signal) {
+  return fetch(url, { signal }).then((response) => {
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    return response.text();
+  }).then((text) => {
+    const parser = new DOMParser();
+    return parser.parseFromString(text, "text/xml");
+  }).catch((error) => {
+    if (error.name === "AbortError") {
+      throw error;
+    }
+    throw new Error(`Failed to load XML: ${error.message}`);
+  });
+}
+function parseXML(xmlDocument) {
+  const parser = new DOMParser();
+  const xmlFragment = parser.parseFromString(xmlDocument, "text/xml");
+  return xmlFragment;
+}
+function stripNamespaces(node, doc, registry) {
+  if (node.nodeType === Node.ELEMENT_NODE) {
+    const el = node;
+    let newEl;
+    if (!el.namespaceURI || el.namespaceURI.startsWith("http://www.imsglobal.org/xsd/qti/") || el.namespaceURI.startsWith("http://www.imsglobal.org/xsd/imsqti")) {
+      newEl = registry ? doc.createElement(el.localName, { customElementRegistry: registry }) : doc.createElement(el.localName);
+    } else {
+      newEl = doc.createElementNS(el.namespaceURI, el.tagName);
+    }
+    for (let i = 0; i < el.attributes.length; i++) {
+      const attr = el.attributes[i];
+      newEl.setAttribute(attr.localName, attr.value);
+    }
+    for (let i = 0; i < el.childNodes.length; i++) {
+      newEl.appendChild(stripNamespaces(el.childNodes[i], doc, registry));
+    }
+    return newEl;
+  }
+  return node.cloneNode(false);
+}
+function toHTML(xmlFragment, registry) {
+  const fragment = document.createDocumentFragment();
+  for (let i = 0; i < xmlFragment.childNodes.length; i++) {
+    fragment.appendChild(stripNamespaces(xmlFragment.childNodes[i], document, registry));
+  }
+  return fragment;
+}
+function setLocation(xmlFragment, location) {
+  if (!location.endsWith("/")) {
+    location += "/";
+  }
+  const allElements = xmlFragment.querySelectorAll("*");
+  allElements.forEach((el) => {
+    for (const attr of ["src", "href", "srcset", "poster"]) {
+      const attrValue = el.getAttribute(attr)?.trim();
+      if (attrValue && !/^(data:|https?:|blob:)/.test(attrValue)) {
+        const newValue = location + encodeURI(attrValue);
+        el.setAttribute(attr, newValue);
+      }
+    }
+  });
+}
+
+// ../qti-transformers/dist/qti-transform-item.js
+var qtiTransformItem = () => {
+  let xmlFragment;
+  let xmlUri = "";
+  const api = {
+    load(uri, signal) {
+      xmlUri = uri;
+      return loadXML(uri, signal).then((xml) => {
+        xmlFragment = xml;
+        return api;
+      });
+    },
+    parse(xmlString) {
+      xmlFragment = parseXML(xmlString);
+      xmlUri = "";
+      return api;
+    },
+    path: (location) => {
+      setLocation(xmlFragment, location);
+      xmlUri = null;
+      return api;
+    },
+    fn(fn) {
+      fn(xmlFragment);
+      return api;
+    },
+    pciHooks(uri) {
+      pciHooks(xmlFragment, uri);
+      return api;
+    },
+    async configurePci(baseUrl, getModuleResolutionConfig, selector = "qti-portable-custom-interaction") {
+      await configurePci(xmlFragment, baseUrl, getModuleResolutionConfig, selector);
+      return api;
+    },
+    shuffleInteractions(seed) {
+      const normalizedSeed = typeof seed === "string" ? seed.trim() : seed;
+      if (normalizedSeed === null || normalizedSeed === void 0 || normalizedSeed === "") {
+        const fallbackSeed = xmlUri || "default-item-seed";
+        warnMissingSeed("qtiTransformItem", fallbackSeed);
+        shuffleInteractions(xmlFragment, fallbackSeed);
+        return api;
+      }
+      shuffleInteractions(xmlFragment, normalizedSeed);
+      return api;
+    },
+    extendElementName: (tagName, extension) => {
+      extendElementName(xmlFragment, tagName, extension);
+      return api;
+    },
+    extendElementsWithClass: (param = "extend") => {
+      extendElementsWithClass(xmlFragment, param);
+      return api;
+    },
+    customInteraction(baseRef, baseItem) {
+      const qtiCustomInteraction = xmlFragment.querySelector("qti-custom-interaction");
+      const qtiCustomInteractionObject = qtiCustomInteraction.querySelector("object");
+      qtiCustomInteraction.setAttribute("data-base-ref", baseRef);
+      qtiCustomInteraction.setAttribute("data-base-item", baseRef + baseItem);
+      qtiCustomInteraction.setAttribute("data", qtiCustomInteractionObject.getAttribute("data"));
+      qtiCustomInteraction.setAttribute("width", qtiCustomInteractionObject.getAttribute("width"));
+      qtiCustomInteraction.setAttribute("height", qtiCustomInteractionObject.getAttribute("height"));
+      qtiCustomInteraction.removeChild(qtiCustomInteractionObject);
+      return api;
+    },
+    convertCDATAtoComment() {
+      convertCDATAtoComment(xmlFragment);
+      return api;
+    },
+    stripStyleSheets() {
+      stripStyleSheets(xmlFragment);
+      return api;
+    },
+    html() {
+      if (xmlUri !== null) {
+        setLocation(xmlFragment, xmlUri.substring(0, xmlUri.lastIndexOf("/")));
+      }
+      return new XMLSerializer().serializeToString(toHTML(xmlFragment));
+    },
+    xml() {
+      return new XMLSerializer().serializeToString(xmlFragment);
+    },
+    htmlDoc(registry) {
+      if (xmlUri !== null) {
+        setLocation(xmlFragment, xmlUri.substring(0, xmlUri.lastIndexOf("/")));
+      }
+      return toHTML(xmlFragment, registry);
+    },
+    xmlDoc() {
+      return xmlFragment;
+    }
+  };
+  return api;
+};
+
+// ../qti-transformers/dist/qti-transform-manifest.js
+var qtiTransformManifest = () => {
+  let xmlFragment;
+  const api = {
+    async load(uri, signal) {
+      return new Promise((resolve) => {
+        loadXML(uri, signal).then((xml) => {
+          xmlFragment = xml;
+          return resolve(api);
+        });
+      });
+    },
+    parse(xmlString) {
+      xmlFragment = parseXML(xmlString);
+    },
+    assessmentTest() {
+      const el = xmlFragment.querySelector('resource[type="imsqti_test_xmlv3p0"]');
+      return { href: el.getAttribute("href"), identifier: el.getAttribute("identifier") };
+    }
+  };
+  return api;
+};
+
+// ../qti-transformers/dist/test/items.js
+function itemsFromTest(xmlFragment) {
+  const items = [];
+  xmlFragment.querySelectorAll("qti-assessment-item-ref").forEach((el) => {
+    const identifier = el.getAttribute("identifier");
+    const href = el.getAttribute("href");
+    const category = el.getAttribute("category");
+    items.push({ identifier, href, category });
+  });
+  return items;
+}
+
+// ../qti-transformers/dist/test/shuffle-sections.js
+var isLocal = (el, ...names) => names.includes(el.localName) || names.includes(el.localName?.toLowerCase?.());
+var isItemRef = (el) => isLocal(el, "qti-assessment-item-ref", "assessmentitemref");
+var isSection = (el) => isLocal(el, "qti-assessment-section", "assessmentsection");
+var attrIsTrue = (el, ...names) => names.some((n) => {
+  const v = (el.getAttribute(n) ?? "").trim().toLowerCase();
+  return v === "true" || v === "1";
+});
+var attrIsFalse = (el, ...names) => names.some((n) => {
+  const v = (el.getAttribute(n) ?? "").trim().toLowerCase();
+  return v === "false" || v === "0";
+});
+var isOrdering = (el) => isLocal(el, "qti-ordering", "ordering");
+var isSelection = (el) => isLocal(el, "qti-selection", "selection");
+var shuffleOrderingElements = (section) => Array.from(section.children).filter((child) => isOrdering(child) && attrIsTrue(child, "shuffle"));
+var rngFor = (seed, key) => createSeededRandom(`${seed}:${key}`);
+function collectItemRefsDeep(section) {
+  const itemRefs = [];
+  const dropped = [];
+  const walk = (el) => {
+    for (const child of Array.from(el.children)) {
+      if (isItemRef(child)) {
+        itemRefs.push(child);
+      } else if (isSection(child)) {
+        walk(child);
+      } else if (!isOrdering(child) && !isSelection(child)) {
+        dropped.push(child.localName);
+      }
+    }
+  };
+  walk(section);
+  return { itemRefs, dropped };
+}
+function warnDroppedChildren(section, dropped) {
+  if (dropped.length === 0)
+    return;
+  const identifier = section.getAttribute("identifier") ?? "(no identifier)";
+  console.warn(`[qtiTransformTest] Subsection "${identifier}" is consumed by section ordering; discarding its ${[...new Set(dropped)].join(", ")}.`);
+}
+function orderSection(section, seed) {
+  for (const child of Array.from(section.children)) {
+    if (isSection(child)) {
+      orderSection(child, seed);
+    }
+  }
+  const orderingEls = shuffleOrderingElements(section);
+  if (orderingEls.length === 0) {
+    return;
+  }
+  const units = [];
+  const toDetach = [];
+  for (const child of Array.from(section.children)) {
+    if (isItemRef(child)) {
+      units.push({ nodes: [child], fixed: attrIsTrue(child, "fixed") });
+      toDetach.push(child);
+    } else if (isSection(child)) {
+      const { itemRefs, dropped } = collectItemRefsDeep(child);
+      warnDroppedChildren(child, dropped);
+      if (attrIsFalse(child, "keep-together", "keeptogether")) {
+        for (const itemRef of itemRefs) {
+          units.push({ nodes: [itemRef], fixed: attrIsTrue(itemRef, "fixed") });
+        }
+      } else if (itemRefs.length > 0) {
+        units.push({ nodes: itemRefs, fixed: attrIsTrue(child, "fixed") });
+      }
+      toDetach.push(child);
+    }
+  }
+  const anchor = toDetach.length > 0 ? toDetach[toDetach.length - 1].nextSibling : null;
+  const sectionKey = section.getAttribute("identifier") ?? "";
+  const ordered = shuffleKeepingFixed(units, rngFor(seed, sectionKey));
+  for (const el of toDetach) {
+    el.remove();
+  }
+  for (const unit of ordered) {
+    for (const node of unit.nodes) {
+      section.insertBefore(node, anchor);
+    }
+  }
+  for (const orderingEl of orderingEls) {
+    orderingEl.remove();
+  }
+}
+function hasShuffleOrdering(doc) {
+  return Array.from(doc.getElementsByTagName("*")).some((el) => isOrdering(el) && attrIsTrue(el, "shuffle"));
+}
+function shuffleSectionsOrdering(doc, seed) {
+  const sections = Array.from(doc.getElementsByTagName("*")).filter((el) => isSection(el));
+  for (const section of sections) {
+    if (!section.parentNode)
+      continue;
+    const parent = section.parentElement;
+    if (parent && isSection(parent))
+      continue;
+    orderSection(section, seed);
+  }
+}
+
+// ../qti-transformers/dist/qti-transform-test.js
+var qtiTransformTest = () => {
+  let xmlFragment;
+  let xmlUri = "";
+  const api = {
+    async load(uri, signal) {
+      return new Promise((resolve, _) => {
+        loadXML(uri, signal).then((xml) => {
+          xmlFragment = xml;
+          xmlUri = uri;
+          api.path(uri.substring(0, uri.lastIndexOf("/")));
+          return resolve(api);
+        });
+      });
+    },
+    parse(xmlString) {
+      xmlFragment = parseXML(xmlString);
+      xmlUri = "";
+      return api;
+    },
+    path: (location) => {
+      setLocation(xmlFragment, location);
+      return api;
+    },
+    fn(fn) {
+      fn(xmlFragment);
+      return api;
+    },
+    shuffleOrdering(seed) {
+      if (!hasShuffleOrdering(xmlFragment)) {
+        return api;
+      }
+      const normalizedSeed = typeof seed === "string" ? seed.trim() : seed;
+      if (normalizedSeed === null || normalizedSeed === void 0 || normalizedSeed === "") {
+        const fallbackSeed = xmlUri || "default-test-seed";
+        warnMissingSeed("qtiTransformTest", fallbackSeed);
+        shuffleSectionsOrdering(xmlFragment, fallbackSeed);
+        return api;
+      }
+      shuffleSectionsOrdering(xmlFragment, normalizedSeed);
+      return api;
+    },
+    items() {
+      return itemsFromTest(xmlFragment);
+    },
+    html() {
+      return new XMLSerializer().serializeToString(toHTML(xmlFragment));
+    },
+    xml() {
+      return new XMLSerializer().serializeToString(xmlFragment);
+    },
+    htmlDoc(registry) {
+      return toHTML(xmlFragment, registry);
+    },
+    xmlDoc() {
+      return xmlFragment;
+    }
+  };
+  return api;
+};
+
+export {
+  qtiTransformItem,
+  qtiTransformManifest,
+  qtiTransformTest
+};
+//# sourceMappingURL=chunk-IJD53WY6.js.map