@webwriter/quiz 1.1.3 → 2.0.0

package/dist/migrate.js

@@ -0,0 +1,1434 @@
+// package.json
+var name = "@webwriter/quiz";
+var version = "2.0.0";
+
+// node_modules/@lit/reactive-element/css-tag.js
+var t = globalThis;
+var e = t.ShadowRoot && (void 0 === t.ShadyCSS || t.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype;
+var s = Symbol();
+var o = /* @__PURE__ */ new WeakMap();
+var n = class {
+  constructor(t3, e4, o5) {
+    if (this._$cssResult$ = true, o5 !== s) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
+    this.cssText = t3, this.t = e4;
+  }
+  get styleSheet() {
+    let t3 = this.o;
+    const s4 = this.t;
+    if (e && void 0 === t3) {
+      const e4 = void 0 !== s4 && 1 === s4.length;
+      e4 && (t3 = o.get(s4)), void 0 === t3 && ((this.o = t3 = new CSSStyleSheet()).replaceSync(this.cssText), e4 && o.set(s4, t3));
+    }
+    return t3;
+  }
+  toString() {
+    return this.cssText;
+  }
+};
+var r = (t3) => new n("string" == typeof t3 ? t3 : t3 + "", void 0, s);
+var S = (s4, o5) => {
+  if (e) s4.adoptedStyleSheets = o5.map((t3) => t3 instanceof CSSStyleSheet ? t3 : t3.styleSheet);
+  else for (const e4 of o5) {
+    const o6 = document.createElement("style"), n4 = t.litNonce;
+    void 0 !== n4 && o6.setAttribute("nonce", n4), o6.textContent = e4.cssText, s4.appendChild(o6);
+  }
+};
+var c = e ? (t3) => t3 : (t3) => t3 instanceof CSSStyleSheet ? ((t4) => {
+  let e4 = "";
+  for (const s4 of t4.cssRules) e4 += s4.cssText;
+  return r(e4);
+})(t3) : t3;
+
+// node_modules/@lit/reactive-element/reactive-element.js
+var { is: i2, defineProperty: e2, getOwnPropertyDescriptor: h, getOwnPropertyNames: r2, getOwnPropertySymbols: o2, getPrototypeOf: n2 } = Object;
+var a = globalThis;
+var c2 = a.trustedTypes;
+var l = c2 ? c2.emptyScript : "";
+var p = a.reactiveElementPolyfillSupport;
+var d = (t3, s4) => t3;
+var u = { toAttribute(t3, s4) {
+  switch (s4) {
+    case Boolean:
+      t3 = t3 ? l : null;
+      break;
+    case Object:
+    case Array:
+      t3 = null == t3 ? t3 : JSON.stringify(t3);
+  }
+  return t3;
+}, fromAttribute(t3, s4) {
+  let i5 = t3;
+  switch (s4) {
+    case Boolean:
+      i5 = null !== t3;
+      break;
+    case Number:
+      i5 = null === t3 ? null : Number(t3);
+      break;
+    case Object:
+    case Array:
+      try {
+        i5 = JSON.parse(t3);
+      } catch (t4) {
+        i5 = null;
+      }
+  }
+  return i5;
+} };
+var f = (t3, s4) => !i2(t3, s4);
+var b = { attribute: true, type: String, converter: u, reflect: false, useDefault: false, hasChanged: f };
+Symbol.metadata ??= Symbol("metadata"), a.litPropertyMetadata ??= /* @__PURE__ */ new WeakMap();
+var y = class extends HTMLElement {
+  static addInitializer(t3) {
+    this._$Ei(), (this.l ??= []).push(t3);
+  }
+  static get observedAttributes() {
+    return this.finalize(), this._$Eh && [...this._$Eh.keys()];
+  }
+  static createProperty(t3, s4 = b) {
+    if (s4.state && (s4.attribute = false), this._$Ei(), this.prototype.hasOwnProperty(t3) && ((s4 = Object.create(s4)).wrapped = true), this.elementProperties.set(t3, s4), !s4.noAccessor) {
+      const i5 = Symbol(), h3 = this.getPropertyDescriptor(t3, i5, s4);
+      void 0 !== h3 && e2(this.prototype, t3, h3);
+    }
+  }
+  static getPropertyDescriptor(t3, s4, i5) {
+    const { get: e4, set: r4 } = h(this.prototype, t3) ?? { get() {
+      return this[s4];
+    }, set(t4) {
+      this[s4] = t4;
+    } };
+    return { get: e4, set(s5) {
+      const h3 = e4?.call(this);
+      r4?.call(this, s5), this.requestUpdate(t3, h3, i5);
+    }, configurable: true, enumerable: true };
+  }
+  static getPropertyOptions(t3) {
+    return this.elementProperties.get(t3) ?? b;
+  }
+  static _$Ei() {
+    if (this.hasOwnProperty(d("elementProperties"))) return;
+    const t3 = n2(this);
+    t3.finalize(), void 0 !== t3.l && (this.l = [...t3.l]), this.elementProperties = new Map(t3.elementProperties);
+  }
+  static finalize() {
+    if (this.hasOwnProperty(d("finalized"))) return;
+    if (this.finalized = true, this._$Ei(), this.hasOwnProperty(d("properties"))) {
+      const t4 = this.properties, s4 = [...r2(t4), ...o2(t4)];
+      for (const i5 of s4) this.createProperty(i5, t4[i5]);
+    }
+    const t3 = this[Symbol.metadata];
+    if (null !== t3) {
+      const s4 = litPropertyMetadata.get(t3);
+      if (void 0 !== s4) for (const [t4, i5] of s4) this.elementProperties.set(t4, i5);
+    }
+    this._$Eh = /* @__PURE__ */ new Map();
+    for (const [t4, s4] of this.elementProperties) {
+      const i5 = this._$Eu(t4, s4);
+      void 0 !== i5 && this._$Eh.set(i5, t4);
+    }
+    this.elementStyles = this.finalizeStyles(this.styles);
+  }
+  static finalizeStyles(s4) {
+    const i5 = [];
+    if (Array.isArray(s4)) {
+      const e4 = new Set(s4.flat(1 / 0).reverse());
+      for (const s5 of e4) i5.unshift(c(s5));
+    } else void 0 !== s4 && i5.push(c(s4));
+    return i5;
+  }
+  static _$Eu(t3, s4) {
+    const i5 = s4.attribute;
+    return false === i5 ? void 0 : "string" == typeof i5 ? i5 : "string" == typeof t3 ? t3.toLowerCase() : void 0;
+  }
+  constructor() {
+    super(), this._$Ep = void 0, this.isUpdatePending = false, this.hasUpdated = false, this._$Em = null, this._$Ev();
+  }
+  _$Ev() {
+    this._$ES = new Promise((t3) => this.enableUpdating = t3), this._$AL = /* @__PURE__ */ new Map(), this._$E_(), this.requestUpdate(), this.constructor.l?.forEach((t3) => t3(this));
+  }
+  addController(t3) {
+    (this._$EO ??= /* @__PURE__ */ new Set()).add(t3), void 0 !== this.renderRoot && this.isConnected && t3.hostConnected?.();
+  }
+  removeController(t3) {
+    this._$EO?.delete(t3);
+  }
+  _$E_() {
+    const t3 = /* @__PURE__ */ new Map(), s4 = this.constructor.elementProperties;
+    for (const i5 of s4.keys()) this.hasOwnProperty(i5) && (t3.set(i5, this[i5]), delete this[i5]);
+    t3.size > 0 && (this._$Ep = t3);
+  }
+  createRenderRoot() {
+    const t3 = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
+    return S(t3, this.constructor.elementStyles), t3;
+  }
+  connectedCallback() {
+    this.renderRoot ??= this.createRenderRoot(), this.enableUpdating(true), this._$EO?.forEach((t3) => t3.hostConnected?.());
+  }
+  enableUpdating(t3) {
+  }
+  disconnectedCallback() {
+    this._$EO?.forEach((t3) => t3.hostDisconnected?.());
+  }
+  attributeChangedCallback(t3, s4, i5) {
+    this._$AK(t3, i5);
+  }
+  _$ET(t3, s4) {
+    const i5 = this.constructor.elementProperties.get(t3), e4 = this.constructor._$Eu(t3, i5);
+    if (void 0 !== e4 && true === i5.reflect) {
+      const h3 = (void 0 !== i5.converter?.toAttribute ? i5.converter : u).toAttribute(s4, i5.type);
+      this._$Em = t3, null == h3 ? this.removeAttribute(e4) : this.setAttribute(e4, h3), this._$Em = null;
+    }
+  }
+  _$AK(t3, s4) {
+    const i5 = this.constructor, e4 = i5._$Eh.get(t3);
+    if (void 0 !== e4 && this._$Em !== e4) {
+      const t4 = i5.getPropertyOptions(e4), h3 = "function" == typeof t4.converter ? { fromAttribute: t4.converter } : void 0 !== t4.converter?.fromAttribute ? t4.converter : u;
+      this._$Em = e4;
+      const r4 = h3.fromAttribute(s4, t4.type);
+      this[e4] = r4 ?? this._$Ej?.get(e4) ?? r4, this._$Em = null;
+    }
+  }
+  requestUpdate(t3, s4, i5, e4 = false, h3) {
+    if (void 0 !== t3) {
+      const r4 = this.constructor;
+      if (false === e4 && (h3 = this[t3]), i5 ??= r4.getPropertyOptions(t3), !((i5.hasChanged ?? f)(h3, s4) || i5.useDefault && i5.reflect && h3 === this._$Ej?.get(t3) && !this.hasAttribute(r4._$Eu(t3, i5)))) return;
+      this.C(t3, s4, i5);
+    }
+    false === this.isUpdatePending && (this._$ES = this._$EP());
+  }
+  C(t3, s4, { useDefault: i5, reflect: e4, wrapped: h3 }, r4) {
+    i5 && !(this._$Ej ??= /* @__PURE__ */ new Map()).has(t3) && (this._$Ej.set(t3, r4 ?? s4 ?? this[t3]), true !== h3 || void 0 !== r4) || (this._$AL.has(t3) || (this.hasUpdated || i5 || (s4 = void 0), this._$AL.set(t3, s4)), true === e4 && this._$Em !== t3 && (this._$Eq ??= /* @__PURE__ */ new Set()).add(t3));
+  }
+  async _$EP() {
+    this.isUpdatePending = true;
+    try {
+      await this._$ES;
+    } catch (t4) {
+      Promise.reject(t4);
+    }
+    const t3 = this.scheduleUpdate();
+    return null != t3 && await t3, !this.isUpdatePending;
+  }
+  scheduleUpdate() {
+    return this.performUpdate();
+  }
+  performUpdate() {
+    if (!this.isUpdatePending) return;
+    if (!this.hasUpdated) {
+      if (this.renderRoot ??= this.createRenderRoot(), this._$Ep) {
+        for (const [t5, s5] of this._$Ep) this[t5] = s5;
+        this._$Ep = void 0;
+      }
+      const t4 = this.constructor.elementProperties;
+      if (t4.size > 0) for (const [s5, i5] of t4) {
+        const { wrapped: t5 } = i5, e4 = this[s5];
+        true !== t5 || this._$AL.has(s5) || void 0 === e4 || this.C(s5, void 0, i5, e4);
+      }
+    }
+    let t3 = false;
+    const s4 = this._$AL;
+    try {
+      t3 = this.shouldUpdate(s4), t3 ? (this.willUpdate(s4), this._$EO?.forEach((t4) => t4.hostUpdate?.()), this.update(s4)) : this._$EM();
+    } catch (s5) {
+      throw t3 = false, this._$EM(), s5;
+    }
+    t3 && this._$AE(s4);
+  }
+  willUpdate(t3) {
+  }
+  _$AE(t3) {
+    this._$EO?.forEach((t4) => t4.hostUpdated?.()), this.hasUpdated || (this.hasUpdated = true, this.firstUpdated(t3)), this.updated(t3);
+  }
+  _$EM() {
+    this._$AL = /* @__PURE__ */ new Map(), this.isUpdatePending = false;
+  }
+  get updateComplete() {
+    return this.getUpdateComplete();
+  }
+  getUpdateComplete() {
+    return this._$ES;
+  }
+  shouldUpdate(t3) {
+    return true;
+  }
+  update(t3) {
+    this._$Eq &&= this._$Eq.forEach((t4) => this._$ET(t4, this[t4])), this._$EM();
+  }
+  updated(t3) {
+  }
+  firstUpdated(t3) {
+  }
+};
+y.elementStyles = [], y.shadowRootOptions = { mode: "open" }, y[d("elementProperties")] = /* @__PURE__ */ new Map(), y[d("finalized")] = /* @__PURE__ */ new Map(), p?.({ ReactiveElement: y }), (a.reactiveElementVersions ??= []).push("2.1.2");
+
+// node_modules/lit-html/lit-html.js
+var t2 = globalThis;
+var i3 = (t3) => t3;
+var s2 = t2.trustedTypes;
+var e3 = s2 ? s2.createPolicy("lit-html", { createHTML: (t3) => t3 }) : void 0;
+var h2 = "$lit$";
+var o3 = `lit$${Math.random().toFixed(9).slice(2)}$`;
+var n3 = "?" + o3;
+var r3 = `<${n3}>`;
+var l2 = document;
+var c3 = () => l2.createComment("");
+var a2 = (t3) => null === t3 || "object" != typeof t3 && "function" != typeof t3;
+var u2 = Array.isArray;
+var d2 = (t3) => u2(t3) || "function" == typeof t3?.[Symbol.iterator];
+var f2 = "[ 	\n\f\r]";
+var v = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g;
+var _ = /-->/g;
+var m = />/g;
+var p2 = RegExp(`>|${f2}(?:([^\\s"'>=/]+)(${f2}*=${f2}*(?:[^ 	
+\f\r"'\`<>=]|("|')|))|$)`, "g");
+var g = /'/g;
+var $ = /"/g;
+var y2 = /^(?:script|style|textarea|title)$/i;
+var x = (t3) => (i5, ...s4) => ({ _$litType$: t3, strings: i5, values: s4 });
+var b2 = x(1);
+var w = x(2);
+var T = x(3);
+var E = Symbol.for("lit-noChange");
+var A = Symbol.for("lit-nothing");
+var C = /* @__PURE__ */ new WeakMap();
+var P = l2.createTreeWalker(l2, 129);
+function V(t3, i5) {
+  if (!u2(t3) || !t3.hasOwnProperty("raw")) throw Error("invalid template strings array");
+  return void 0 !== e3 ? e3.createHTML(i5) : i5;
+}
+var N = (t3, i5) => {
+  const s4 = t3.length - 1, e4 = [];
+  let n4, l3 = 2 === i5 ? "<svg>" : 3 === i5 ? "<math>" : "", c4 = v;
+  for (let i6 = 0; i6 < s4; i6++) {
+    const s5 = t3[i6];
+    let a3, u3, d3 = -1, f3 = 0;
+    for (; f3 < s5.length && (c4.lastIndex = f3, u3 = c4.exec(s5), null !== u3); ) f3 = c4.lastIndex, c4 === v ? "!--" === u3[1] ? c4 = _ : void 0 !== u3[1] ? c4 = m : void 0 !== u3[2] ? (y2.test(u3[2]) && (n4 = RegExp("</" + u3[2], "g")), c4 = p2) : void 0 !== u3[3] && (c4 = p2) : c4 === p2 ? ">" === u3[0] ? (c4 = n4 ?? v, d3 = -1) : void 0 === u3[1] ? d3 = -2 : (d3 = c4.lastIndex - u3[2].length, a3 = u3[1], c4 = void 0 === u3[3] ? p2 : '"' === u3[3] ? $ : g) : c4 === $ || c4 === g ? c4 = p2 : c4 === _ || c4 === m ? c4 = v : (c4 = p2, n4 = void 0);
+    const x2 = c4 === p2 && t3[i6 + 1].startsWith("/>") ? " " : "";
+    l3 += c4 === v ? s5 + r3 : d3 >= 0 ? (e4.push(a3), s5.slice(0, d3) + h2 + s5.slice(d3) + o3 + x2) : s5 + o3 + (-2 === d3 ? i6 : x2);
+  }
+  return [V(t3, l3 + (t3[s4] || "<?>") + (2 === i5 ? "</svg>" : 3 === i5 ? "</math>" : "")), e4];
+};
+var S2 = class _S {
+  constructor({ strings: t3, _$litType$: i5 }, e4) {
+    let r4;
+    this.parts = [];
+    let l3 = 0, a3 = 0;
+    const u3 = t3.length - 1, d3 = this.parts, [f3, v2] = N(t3, i5);
+    if (this.el = _S.createElement(f3, e4), P.currentNode = this.el.content, 2 === i5 || 3 === i5) {
+      const t4 = this.el.content.firstChild;
+      t4.replaceWith(...t4.childNodes);
+    }
+    for (; null !== (r4 = P.nextNode()) && d3.length < u3; ) {
+      if (1 === r4.nodeType) {
+        if (r4.hasAttributes()) for (const t4 of r4.getAttributeNames()) if (t4.endsWith(h2)) {
+          const i6 = v2[a3++], s4 = r4.getAttribute(t4).split(o3), e5 = /([.?@])?(.*)/.exec(i6);
+          d3.push({ type: 1, index: l3, name: e5[2], strings: s4, ctor: "." === e5[1] ? I : "?" === e5[1] ? L : "@" === e5[1] ? z : H }), r4.removeAttribute(t4);
+        } else t4.startsWith(o3) && (d3.push({ type: 6, index: l3 }), r4.removeAttribute(t4));
+        if (y2.test(r4.tagName)) {
+          const t4 = r4.textContent.split(o3), i6 = t4.length - 1;
+          if (i6 > 0) {
+            r4.textContent = s2 ? s2.emptyScript : "";
+            for (let s4 = 0; s4 < i6; s4++) r4.append(t4[s4], c3()), P.nextNode(), d3.push({ type: 2, index: ++l3 });
+            r4.append(t4[i6], c3());
+          }
+        }
+      } else if (8 === r4.nodeType) if (r4.data === n3) d3.push({ type: 2, index: l3 });
+      else {
+        let t4 = -1;
+        for (; -1 !== (t4 = r4.data.indexOf(o3, t4 + 1)); ) d3.push({ type: 7, index: l3 }), t4 += o3.length - 1;
+      }
+      l3++;
+    }
+  }
+  static createElement(t3, i5) {
+    const s4 = l2.createElement("template");
+    return s4.innerHTML = t3, s4;
+  }
+};
+function M(t3, i5, s4 = t3, e4) {
+  if (i5 === E) return i5;
+  let h3 = void 0 !== e4 ? s4._$Co?.[e4] : s4._$Cl;
+  const o5 = a2(i5) ? void 0 : i5._$litDirective$;
+  return h3?.constructor !== o5 && (h3?._$AO?.(false), void 0 === o5 ? h3 = void 0 : (h3 = new o5(t3), h3._$AT(t3, s4, e4)), void 0 !== e4 ? (s4._$Co ??= [])[e4] = h3 : s4._$Cl = h3), void 0 !== h3 && (i5 = M(t3, h3._$AS(t3, i5.values), h3, e4)), i5;
+}
+var R = class {
+  constructor(t3, i5) {
+    this._$AV = [], this._$AN = void 0, this._$AD = t3, this._$AM = i5;
+  }
+  get parentNode() {
+    return this._$AM.parentNode;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  u(t3) {
+    const { el: { content: i5 }, parts: s4 } = this._$AD, e4 = (t3?.creationScope ?? l2).importNode(i5, true);
+    P.currentNode = e4;
+    let h3 = P.nextNode(), o5 = 0, n4 = 0, r4 = s4[0];
+    for (; void 0 !== r4; ) {
+      if (o5 === r4.index) {
+        let i6;
+        2 === r4.type ? i6 = new k(h3, h3.nextSibling, this, t3) : 1 === r4.type ? i6 = new r4.ctor(h3, r4.name, r4.strings, this, t3) : 6 === r4.type && (i6 = new Z(h3, this, t3)), this._$AV.push(i6), r4 = s4[++n4];
+      }
+      o5 !== r4?.index && (h3 = P.nextNode(), o5++);
+    }
+    return P.currentNode = l2, e4;
+  }
+  p(t3) {
+    let i5 = 0;
+    for (const s4 of this._$AV) void 0 !== s4 && (void 0 !== s4.strings ? (s4._$AI(t3, s4, i5), i5 += s4.strings.length - 2) : s4._$AI(t3[i5])), i5++;
+  }
+};
+var k = class _k {
+  get _$AU() {
+    return this._$AM?._$AU ?? this._$Cv;
+  }
+  constructor(t3, i5, s4, e4) {
+    this.type = 2, this._$AH = A, this._$AN = void 0, this._$AA = t3, this._$AB = i5, this._$AM = s4, this.options = e4, this._$Cv = e4?.isConnected ?? true;
+  }
+  get parentNode() {
+    let t3 = this._$AA.parentNode;
+    const i5 = this._$AM;
+    return void 0 !== i5 && 11 === t3?.nodeType && (t3 = i5.parentNode), t3;
+  }
+  get startNode() {
+    return this._$AA;
+  }
+  get endNode() {
+    return this._$AB;
+  }
+  _$AI(t3, i5 = this) {
+    t3 = M(this, t3, i5), a2(t3) ? t3 === A || null == t3 || "" === t3 ? (this._$AH !== A && this._$AR(), this._$AH = A) : t3 !== this._$AH && t3 !== E && this._(t3) : void 0 !== t3._$litType$ ? this.$(t3) : void 0 !== t3.nodeType ? this.T(t3) : d2(t3) ? this.k(t3) : this._(t3);
+  }
+  O(t3) {
+    return this._$AA.parentNode.insertBefore(t3, this._$AB);
+  }
+  T(t3) {
+    this._$AH !== t3 && (this._$AR(), this._$AH = this.O(t3));
+  }
+  _(t3) {
+    this._$AH !== A && a2(this._$AH) ? this._$AA.nextSibling.data = t3 : this.T(l2.createTextNode(t3)), this._$AH = t3;
+  }
+  $(t3) {
+    const { values: i5, _$litType$: s4 } = t3, e4 = "number" == typeof s4 ? this._$AC(t3) : (void 0 === s4.el && (s4.el = S2.createElement(V(s4.h, s4.h[0]), this.options)), s4);
+    if (this._$AH?._$AD === e4) this._$AH.p(i5);
+    else {
+      const t4 = new R(e4, this), s5 = t4.u(this.options);
+      t4.p(i5), this.T(s5), this._$AH = t4;
+    }
+  }
+  _$AC(t3) {
+    let i5 = C.get(t3.strings);
+    return void 0 === i5 && C.set(t3.strings, i5 = new S2(t3)), i5;
+  }
+  k(t3) {
+    u2(this._$AH) || (this._$AH = [], this._$AR());
+    const i5 = this._$AH;
+    let s4, e4 = 0;
+    for (const h3 of t3) e4 === i5.length ? i5.push(s4 = new _k(this.O(c3()), this.O(c3()), this, this.options)) : s4 = i5[e4], s4._$AI(h3), e4++;
+    e4 < i5.length && (this._$AR(s4 && s4._$AB.nextSibling, e4), i5.length = e4);
+  }
+  _$AR(t3 = this._$AA.nextSibling, s4) {
+    for (this._$AP?.(false, true, s4); t3 !== this._$AB; ) {
+      const s5 = i3(t3).nextSibling;
+      i3(t3).remove(), t3 = s5;
+    }
+  }
+  setConnected(t3) {
+    void 0 === this._$AM && (this._$Cv = t3, this._$AP?.(t3));
+  }
+};
+var H = class {
+  get tagName() {
+    return this.element.tagName;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  constructor(t3, i5, s4, e4, h3) {
+    this.type = 1, this._$AH = A, this._$AN = void 0, this.element = t3, this.name = i5, this._$AM = e4, this.options = h3, s4.length > 2 || "" !== s4[0] || "" !== s4[1] ? (this._$AH = Array(s4.length - 1).fill(new String()), this.strings = s4) : this._$AH = A;
+  }
+  _$AI(t3, i5 = this, s4, e4) {
+    const h3 = this.strings;
+    let o5 = false;
+    if (void 0 === h3) t3 = M(this, t3, i5, 0), o5 = !a2(t3) || t3 !== this._$AH && t3 !== E, o5 && (this._$AH = t3);
+    else {
+      const e5 = t3;
+      let n4, r4;
+      for (t3 = h3[0], n4 = 0; n4 < h3.length - 1; n4++) r4 = M(this, e5[s4 + n4], i5, n4), r4 === E && (r4 = this._$AH[n4]), o5 ||= !a2(r4) || r4 !== this._$AH[n4], r4 === A ? t3 = A : t3 !== A && (t3 += (r4 ?? "") + h3[n4 + 1]), this._$AH[n4] = r4;
+    }
+    o5 && !e4 && this.j(t3);
+  }
+  j(t3) {
+    t3 === A ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, t3 ?? "");
+  }
+};
+var I = class extends H {
+  constructor() {
+    super(...arguments), this.type = 3;
+  }
+  j(t3) {
+    this.element[this.name] = t3 === A ? void 0 : t3;
+  }
+};
+var L = class extends H {
+  constructor() {
+    super(...arguments), this.type = 4;
+  }
+  j(t3) {
+    this.element.toggleAttribute(this.name, !!t3 && t3 !== A);
+  }
+};
+var z = class extends H {
+  constructor(t3, i5, s4, e4, h3) {
+    super(t3, i5, s4, e4, h3), this.type = 5;
+  }
+  _$AI(t3, i5 = this) {
+    if ((t3 = M(this, t3, i5, 0) ?? A) === E) return;
+    const s4 = this._$AH, e4 = t3 === A && s4 !== A || t3.capture !== s4.capture || t3.once !== s4.once || t3.passive !== s4.passive, h3 = t3 !== A && (s4 === A || e4);
+    e4 && this.element.removeEventListener(this.name, this, s4), h3 && this.element.addEventListener(this.name, this, t3), this._$AH = t3;
+  }
+  handleEvent(t3) {
+    "function" == typeof this._$AH ? this._$AH.call(this.options?.host ?? this.element, t3) : this._$AH.handleEvent(t3);
+  }
+};
+var Z = class {
+  constructor(t3, i5, s4) {
+    this.element = t3, this.type = 6, this._$AN = void 0, this._$AM = i5, this.options = s4;
+  }
+  get _$AU() {
+    return this._$AM._$AU;
+  }
+  _$AI(t3) {
+    M(this, t3);
+  }
+};
+var B = t2.litHtmlPolyfillSupport;
+B?.(S2, k), (t2.litHtmlVersions ??= []).push("3.3.3");
+var D = (t3, i5, s4) => {
+  const e4 = s4?.renderBefore ?? i5;
+  let h3 = e4._$litPart$;
+  if (void 0 === h3) {
+    const t4 = s4?.renderBefore ?? null;
+    e4._$litPart$ = h3 = new k(i5.insertBefore(c3(), t4), t4, void 0, s4 ?? {});
+  }
+  return h3._$AI(t3), h3;
+};
+
+// node_modules/lit-element/lit-element.js
+var s3 = globalThis;
+var i4 = class extends y {
+  constructor() {
+    super(...arguments), this.renderOptions = { host: this }, this._$Do = void 0;
+  }
+  createRenderRoot() {
+    const t3 = super.createRenderRoot();
+    return this.renderOptions.renderBefore ??= t3.firstChild, t3;
+  }
+  update(t3) {
+    const r4 = this.render();
+    this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(t3), this._$Do = D(r4, this.renderRoot, this.renderOptions);
+  }
+  connectedCallback() {
+    super.connectedCallback(), this._$Do?.setConnected(true);
+  }
+  disconnectedCallback() {
+    super.disconnectedCallback(), this._$Do?.setConnected(false);
+  }
+  render() {
+    return E;
+  }
+};
+i4._$litElement$ = true, i4["finalized"] = true, s3.litElementHydrateSupport?.({ LitElement: i4 });
+var o4 = s3.litElementPolyfillSupport;
+o4?.({ LitElement: i4 });
+(s3.litElementVersions ??= []).push("4.2.2");
+
+// src/lib/encrypted-property.ts
+var VERSION = 3;
+var KEY_LENGTH = 16;
+var LENGTH_LENGTH = 4;
+var MIN_PADDING_LENGTH = 2;
+var PADDING_BLOCK_LENGTH = 8;
+var HEADER_LENGTH = 1 + KEY_LENGTH;
+var encoder = new TextEncoder();
+var decoder = new TextDecoder("utf-8", { fatal: true });
+function randomBytes(length) {
+  const bytes = new Uint8Array(length);
+  if (globalThis.crypto?.getRandomValues) {
+    return globalThis.crypto.getRandomValues(bytes);
+  }
+  for (let index = 0; index < length; index++) {
+    bytes[index] = Math.floor(Math.random() * 256);
+  }
+  return bytes;
+}
+function paddedLength(plaintextLength) {
+  const minimumLength = LENGTH_LENGTH + plaintextLength + MIN_PADDING_LENGTH;
+  const roundedLength = Math.ceil(minimumLength / PADDING_BLOCK_LENGTH) * PADDING_BLOCK_LENGTH;
+  return roundedLength + randomBytes(1)[0] % 2 * PADDING_BLOCK_LENGTH;
+}
+function applyKeystream(bytes, key) {
+  const result = new Uint8Array(bytes.length);
+  const state = new Uint32Array(4);
+  const keyView = new DataView(key.buffer, key.byteOffset, key.byteLength);
+  for (let index = 0; index < state.length; index++) {
+    state[index] = keyView.getUint32(index * 4);
+  }
+  if (state.every((word) => word === 0)) {
+    state[0] = 1;
+  }
+  for (let index = 0; index < bytes.length; index++) {
+    let next = state[3];
+    const first = state[0];
+    state[3] = state[2];
+    state[2] = state[1];
+    state[1] = first;
+    next ^= next << 11;
+    next ^= next >>> 8;
+    state[0] = next ^ first ^ first >>> 19;
+    result[index] = bytes[index] ^ state[0];
+  }
+  return result;
+}
+function toBase64(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+function fromBase64(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index++) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+function decryptAttribute(value) {
+  const payload = fromBase64(value);
+  if (payload[0] !== VERSION || payload.length < HEADER_LENGTH + LENGTH_LENGTH) {
+    throw new Error("Not an encrypted property");
+  }
+  const key = payload.subarray(1, HEADER_LENGTH);
+  const framedPlaintext = applyKeystream(payload.subarray(HEADER_LENGTH), key);
+  const plaintextLength = new DataView(
+    framedPlaintext.buffer,
+    framedPlaintext.byteOffset,
+    framedPlaintext.byteLength
+  ).getUint32(0);
+  if (plaintextLength > framedPlaintext.length - LENGTH_LENGTH) {
+    throw new Error("Invalid encrypted property");
+  }
+  return JSON.parse(
+    decoder.decode(
+      framedPlaintext.subarray(LENGTH_LENGTH, LENGTH_LENGTH + plaintextLength)
+    )
+  );
+}
+var encryptedProperty = {
+  toAttribute(value) {
+    if (value == null) {
+      return value;
+    }
+    const plaintext = encoder.encode(JSON.stringify(value));
+    const framedPlaintext = randomBytes(paddedLength(plaintext.length));
+    new DataView(framedPlaintext.buffer).setUint32(0, plaintext.length);
+    framedPlaintext.set(plaintext, LENGTH_LENGTH);
+    const key = randomBytes(KEY_LENGTH);
+    const ciphertext = applyKeystream(framedPlaintext, key);
+    const payload = new Uint8Array(HEADER_LENGTH + ciphertext.length);
+    payload[0] = VERSION;
+    payload.set(key, 1);
+    payload.set(ciphertext, HEADER_LENGTH);
+    return toBase64(payload);
+  },
+  fromAttribute(value, type) {
+    if (value == null) {
+      return null;
+    }
+    try {
+      return decryptAttribute(value);
+    } catch {
+      return u.fromAttribute?.(value, type);
+    }
+  }
+};
+
+// src/migrate/legacy-solution.ts
+var LEGACY_PASSWORD = "B08bxd82SAOf";
+var PBKDF2_ITERATIONS = 1e5;
+var GCM_TAG_LENGTH = 16;
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var INITIAL_STATE = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var schedule = new Uint32Array(64);
+function compress(state, block, offset) {
+  for (let i5 = 0; i5 < 16; i5++) {
+    const j = offset + i5 * 4;
+    schedule[i5] = block[j] << 24 | block[j + 1] << 16 | block[j + 2] << 8 | block[j + 3];
+  }
+  for (let i5 = 16; i5 < 64; i5++) {
+    const x2 = schedule[i5 - 15];
+    const y3 = schedule[i5 - 2];
+    const s0 = (x2 >>> 7 | x2 << 25) ^ (x2 >>> 18 | x2 << 14) ^ x2 >>> 3;
+    const s1 = (y3 >>> 17 | y3 << 15) ^ (y3 >>> 19 | y3 << 13) ^ y3 >>> 10;
+    schedule[i5] = schedule[i5 - 16] + s0 + schedule[i5 - 7] + s1 | 0;
+  }
+  let a3 = state[0];
+  let b3 = state[1];
+  let c4 = state[2];
+  let d3 = state[3];
+  let e4 = state[4];
+  let f3 = state[5];
+  let g2 = state[6];
+  let h3 = state[7];
+  for (let i5 = 0; i5 < 64; i5++) {
+    const s1 = (e4 >>> 6 | e4 << 26) ^ (e4 >>> 11 | e4 << 21) ^ (e4 >>> 25 | e4 << 7);
+    const ch = e4 & f3 ^ ~e4 & g2;
+    const t1 = h3 + s1 + ch + K[i5] + schedule[i5] | 0;
+    const s0 = (a3 >>> 2 | a3 << 30) ^ (a3 >>> 13 | a3 << 19) ^ (a3 >>> 22 | a3 << 10);
+    const maj = a3 & b3 ^ a3 & c4 ^ b3 & c4;
+    const t22 = s0 + maj | 0;
+    h3 = g2;
+    g2 = f3;
+    f3 = e4;
+    e4 = d3 + t1 | 0;
+    d3 = c4;
+    c4 = b3;
+    b3 = a3;
+    a3 = t1 + t22 | 0;
+  }
+  state[0] = state[0] + a3 | 0;
+  state[1] = state[1] + b3 | 0;
+  state[2] = state[2] + c4 | 0;
+  state[3] = state[3] + d3 | 0;
+  state[4] = state[4] + e4 | 0;
+  state[5] = state[5] + f3 | 0;
+  state[6] = state[6] + g2 | 0;
+  state[7] = state[7] + h3 | 0;
+}
+var tailBlock = new Uint8Array(128);
+var tailView = new DataView(tailBlock.buffer);
+function absorb(state, data, prefixLength) {
+  let i5 = 0;
+  for (; i5 + 64 <= data.length; i5 += 64) compress(state, data, i5);
+  const rest = data.length - i5;
+  const size = rest <= 55 ? 64 : 128;
+  tailBlock.fill(0, 0, size);
+  tailBlock.set(data.subarray(i5), 0);
+  tailBlock[rest] = 128;
+  const bits = (prefixLength + data.length) * 8;
+  tailView.setUint32(size - 8, Math.floor(bits / 4294967296));
+  tailView.setUint32(size - 4, bits >>> 0);
+  for (let j = 0; j < size; j += 64) compress(state, tailBlock, j);
+}
+function writeState(state, out) {
+  for (let i5 = 0; i5 < 8; i5++) {
+    out[i5 * 4] = state[i5] >>> 24;
+    out[i5 * 4 + 1] = state[i5] >>> 16 & 255;
+    out[i5 * 4 + 2] = state[i5] >>> 8 & 255;
+    out[i5 * 4 + 3] = state[i5] & 255;
+  }
+}
+function sha256(data) {
+  const state = INITIAL_STATE.slice();
+  absorb(state, data, 0);
+  const out = new Uint8Array(32);
+  writeState(state, out);
+  return out;
+}
+function hmacStates(key) {
+  const normalized = key.length > 64 ? sha256(key) : key;
+  const ipad = new Uint8Array(64);
+  const opad = new Uint8Array(64);
+  ipad.set(normalized);
+  opad.set(normalized);
+  for (let i5 = 0; i5 < 64; i5++) {
+    ipad[i5] ^= 54;
+    opad[i5] ^= 92;
+  }
+  const inner = INITIAL_STATE.slice();
+  compress(inner, ipad, 0);
+  const outer = INITIAL_STATE.slice();
+  compress(outer, opad, 0);
+  return { inner, outer };
+}
+var hmacDigest = new Uint8Array(32);
+function hmacInto(states, message, out) {
+  const inner = states.inner.slice();
+  absorb(inner, message, 64);
+  writeState(inner, hmacDigest);
+  const outer = states.outer.slice();
+  absorb(outer, hmacDigest, 64);
+  writeState(outer, out);
+}
+function pbkdf2Sha256(password, salt, iterations, keyLength) {
+  const states = hmacStates(password);
+  const derived = new Uint8Array(keyLength);
+  const input = new Uint8Array(salt.length + 4);
+  const inputView = new DataView(input.buffer);
+  const u3 = new Uint8Array(32);
+  const t3 = new Uint8Array(32);
+  input.set(salt);
+  for (let block = 1; block <= Math.ceil(keyLength / 32); block++) {
+    inputView.setUint32(salt.length, block);
+    hmacInto(states, input, u3);
+    t3.set(u3);
+    for (let i5 = 1; i5 < iterations; i5++) {
+      hmacInto(states, u3, u3);
+      for (let j = 0; j < 32; j++) t3[j] ^= u3[j];
+    }
+    derived.set(t3.subarray(0, Math.min(32, keyLength - (block - 1) * 32)), (block - 1) * 32);
+  }
+  return derived;
+}
+var SBOX = new Uint8Array(256);
+{
+  const rotl8 = (x2, shift) => (x2 << shift | x2 >>> 8 - shift) & 255;
+  let p3 = 1;
+  let q = 1;
+  do {
+    p3 = (p3 ^ p3 << 1 ^ (p3 & 128 ? 27 : 0)) & 255;
+    q ^= q << 1;
+    q ^= q << 2;
+    q ^= q << 4;
+    q &= 255;
+    if (q & 128) q ^= 9;
+    SBOX[p3] = (q ^ rotl8(q, 1) ^ rotl8(q, 2) ^ rotl8(q, 3) ^ rotl8(q, 4) ^ 99) & 255;
+  } while (p3 !== 1);
+  SBOX[0] = 99;
+}
+var xtime = (x2) => (x2 << 1 ^ (x2 & 128 ? 27 : 0)) & 255;
+var AES_ROUNDS = 14;
+var AES_KEY_WORDS = 8;
+function expandKey(key) {
+  const roundKeys = new Uint8Array(16 * (AES_ROUNDS + 1));
+  roundKeys.set(key);
+  let rcon = 1;
+  for (let i5 = AES_KEY_WORDS; i5 < 4 * (AES_ROUNDS + 1); i5++) {
+    const previous = (i5 - 1) * 4;
+    let t0 = roundKeys[previous];
+    let t1 = roundKeys[previous + 1];
+    let t22 = roundKeys[previous + 2];
+    let t3 = roundKeys[previous + 3];
+    if (i5 % AES_KEY_WORDS === 0) {
+      const rotated = t0;
+      t0 = SBOX[t1] ^ rcon;
+      t1 = SBOX[t22];
+      t22 = SBOX[t3];
+      t3 = SBOX[rotated];
+      rcon = xtime(rcon);
+    } else if (i5 % AES_KEY_WORDS === 4) {
+      t0 = SBOX[t0];
+      t1 = SBOX[t1];
+      t22 = SBOX[t22];
+      t3 = SBOX[t3];
+    }
+    const target = i5 * 4;
+    const source = (i5 - AES_KEY_WORDS) * 4;
+    roundKeys[target] = roundKeys[source] ^ t0;
+    roundKeys[target + 1] = roundKeys[source + 1] ^ t1;
+    roundKeys[target + 2] = roundKeys[source + 2] ^ t22;
+    roundKeys[target + 3] = roundKeys[source + 3] ^ t3;
+  }
+  return roundKeys;
+}
+function encryptBlock(roundKeys, block) {
+  for (let i5 = 0; i5 < 16; i5++) block[i5] ^= roundKeys[i5];
+  for (let round = 1; round <= AES_ROUNDS; round++) {
+    for (let i5 = 0; i5 < 16; i5++) block[i5] = SBOX[block[i5]];
+    let swap = block[1];
+    block[1] = block[5];
+    block[5] = block[9];
+    block[9] = block[13];
+    block[13] = swap;
+    swap = block[2];
+    const swap2 = block[6];
+    block[2] = block[10];
+    block[6] = block[14];
+    block[10] = swap;
+    block[14] = swap2;
+    swap = block[15];
+    block[15] = block[11];
+    block[11] = block[7];
+    block[7] = block[3];
+    block[3] = swap;
+    if (round < AES_ROUNDS) {
+      for (let c4 = 0; c4 < 16; c4 += 4) {
+        const a0 = block[c4];
+        const a1 = block[c4 + 1];
+        const a22 = block[c4 + 2];
+        const a3 = block[c4 + 3];
+        const all = a0 ^ a1 ^ a22 ^ a3;
+        block[c4] = a0 ^ all ^ xtime(a0 ^ a1);
+        block[c4 + 1] = a1 ^ all ^ xtime(a1 ^ a22);
+        block[c4 + 2] = a22 ^ all ^ xtime(a22 ^ a3);
+        block[c4 + 3] = a3 ^ all ^ xtime(a3 ^ a0);
+      }
+    }
+    const offset = round * 16;
+    for (let i5 = 0; i5 < 16; i5++) block[i5] ^= roundKeys[offset + i5];
+  }
+}
+function aesGcmDecrypt(key, iv, payload) {
+  if (iv.length !== 12) throw new Error(`Unsupported IV length: ${iv.length}`);
+  if (payload.length < GCM_TAG_LENGTH) throw new Error("Ciphertext too short");
+  const roundKeys = expandKey(key);
+  const ciphertext = payload.subarray(0, payload.length - GCM_TAG_LENGTH);
+  const plaintext = new Uint8Array(ciphertext.length);
+  const counter = new Uint8Array(16);
+  const keystream = new Uint8Array(16);
+  counter.set(iv);
+  counter[15] = 1;
+  for (let offset = 0; offset < ciphertext.length; offset += 16) {
+    for (let i5 = 15; i5 >= 12; i5--) {
+      counter[i5] = counter[i5] + 1 & 255;
+      if (counter[i5] !== 0) break;
+    }
+    keystream.set(counter);
+    encryptBlock(roundKeys, keystream);
+    const length = Math.min(16, ciphertext.length - offset);
+    for (let i5 = 0; i5 < length; i5++) plaintext[offset + i5] = ciphertext[offset + i5] ^ keystream[i5];
+  }
+  return plaintext;
+}
+function dataUrlToBytes(url) {
+  const comma = url.indexOf(",");
+  if (comma === -1) throw new Error("Not a data URL");
+  const payload = url.slice(comma + 1);
+  if (!/;base64/i.test(url.slice(0, comma))) {
+    return new TextEncoder().encode(decodeURIComponent(payload));
+  }
+  const binary = atob(payload);
+  const bytes = new Uint8Array(binary.length);
+  for (let i5 = 0; i5 < binary.length; i5++) bytes[i5] = binary.charCodeAt(i5);
+  return bytes;
+}
+function decryptLegacySolution(solution, iv, salt) {
+  const key = pbkdf2Sha256(new TextEncoder().encode(LEGACY_PASSWORD), dataUrlToBytes(salt), PBKDF2_ITERATIONS, 32);
+  const plaintext = aesGcmDecrypt(key, dataUrlToBytes(iv), dataUrlToBytes(solution));
+  return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(plaintext));
+}
+
+// src/migrate/index.ts
+var CURRENT_MAJOR_VERSION = Number(version.split(".")[0]);
+var ANSWER_TAGS = /* @__PURE__ */ new Set([
+  "webwriter-choice",
+  "webwriter-true-false",
+  "webwriter-order",
+  "webwriter-text",
+  "webwriter-mark",
+  "webwriter-gap",
+  "webwriter-pairing",
+  "webwriter-speech"
+]);
+var generatedQuizzes = /* @__PURE__ */ new WeakSet();
+var dragAndDropClozes = /* @__PURE__ */ new WeakSet();
+var taskSolutions = /* @__PURE__ */ new WeakMap();
+var segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+function warn(message, ...details) {
+  console.warn(`[${name}] ${message}`, ...details);
+}
+function uniqueId() {
+  const uuid = crypto.randomUUID?.() ?? `${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}`;
+  return `ww-${uuid}`;
+}
+function markAsCurrent(el) {
+  for (const cls of Array.from(el.classList)) {
+    if (cls.startsWith("ww-v")) el.classList.remove(cls);
+  }
+  el.classList.add("ww-widget", `ww-v${version}`, `ww-pkg-${name}`);
+  if (!el.id) el.id = uniqueId();
+}
+function createWidget(tag, id) {
+  const el = document.createElement(tag);
+  if (id) el.id = id;
+  markAsCurrent(el);
+  return el;
+}
+function retag(el, tag) {
+  const replacement = document.createElement(tag);
+  for (const name2 of el.getAttributeNames()) replacement.setAttribute(name2, el.getAttribute(name2));
+  replacement.append(...Array.from(el.childNodes));
+  markAsCurrent(replacement);
+  el.replaceWith(replacement);
+  return replacement;
+}
+function removeAttributes(el, ...names) {
+  for (const name2 of names) el.removeAttribute(name2);
+}
+function renameAttribute(el, from, to) {
+  if (!el.hasAttribute(from)) return;
+  el.setAttribute(to, el.getAttribute(from));
+  el.removeAttribute(from);
+}
+function parseJson(value) {
+  if (!value) return void 0;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function setSolution(el, value) {
+  const attribute = encryptedProperty.toAttribute?.(value, Array);
+  if (typeof attribute === "string") el.setAttribute("solution", attribute);
+}
+function getTaskSolution(el) {
+  const task = el.closest("webwriter-task");
+  if (!task) return void 0;
+  if (taskSolutions.has(task)) return taskSolutions.get(task);
+  const solution = task.getAttribute("solution");
+  const iv = task.getAttribute("iv");
+  const salt = task.getAttribute("salt");
+  let value = void 0;
+  if (solution && iv && salt) {
+    try {
+      value = decryptLegacySolution(solution, iv, salt);
+    } catch (error) {
+      warn("Could not decrypt the solution of a task, it will have to be entered again.", task, error);
+    }
+  }
+  taskSolutions.set(task, value);
+  return value;
+}
+function migrateQuiz(el) {
+  removeAttributes(el, "randomorder", "counter", "submitted");
+  markAsCurrent(el);
+}
+function ensurePrompt(task) {
+  let prompt = task.querySelector(":scope > webwriter-task-prompt");
+  if (!prompt) {
+    prompt = createWidget("webwriter-task-prompt");
+    prompt.appendChild(document.createElement("p"));
+    task.insertBefore(prompt, task.firstChild);
+  }
+  prompt.setAttribute("slot", "prompt");
+  return prompt;
+}
+function ensureQuiz(task) {
+  const parent = task.parentElement;
+  if (!parent || parent.localName === "webwriter-quiz") return;
+  const previous = task.previousElementSibling;
+  if (previous && generatedQuizzes.has(previous)) {
+    previous.appendChild(task);
+    return;
+  }
+  const quiz = createWidget("webwriter-quiz");
+  generatedQuizzes.add(quiz);
+  parent.insertBefore(quiz, task);
+  quiz.appendChild(task);
+}
+function migrateTask(el) {
+  const solution = getTaskSolution(el);
+  removeAttributes(el, "solution", "iv", "salt", "hint", "submitted", "counter");
+  applyAnswerSolution(el, solution);
+  ensurePrompt(el);
+  markAsCurrent(el);
+  ensureQuiz(el);
+}
+function migratePrompt(el) {
+  el.setAttribute("slot", "prompt");
+  markAsCurrent(el);
+}
+var BLOCK_TAGS = /* @__PURE__ */ new Set(["div", "section", "article", "ul", "ol", "li", "blockquote", "pre", "figure"]);
+function appendAsParagraphs(target, nodes) {
+  let paragraph;
+  for (const node of nodes) {
+    const tag = node.nodeType === Node.ELEMENT_NODE ? node.localName : void 0;
+    if (tag === "p") {
+      target.appendChild(node);
+      paragraph = void 0;
+    } else if (tag && (BLOCK_TAGS.has(tag) || /^h[1-6]$/.test(tag))) {
+      const replacement = document.createElement("p");
+      replacement.append(...Array.from(node.childNodes));
+      target.appendChild(replacement);
+      paragraph = void 0;
+    } else if (node.nodeType !== Node.TEXT_NODE || node.textContent?.trim()) {
+      if (!paragraph) {
+        paragraph = document.createElement("p");
+        target.appendChild(paragraph);
+      }
+      paragraph.appendChild(node);
+    }
+  }
+}
+function ensureHint(task, id) {
+  const prompt = ensurePrompt(task);
+  let hint = prompt.querySelector(":scope > webwriter-quiz-hint");
+  if (!hint) {
+    hint = createWidget("webwriter-quiz-hint", id);
+    hint.setAttribute("slot", "hint");
+    prompt.prepend(hint);
+  }
+  return hint;
+}
+function foldIntoHint(el, id) {
+  const task = el.closest("webwriter-task");
+  if (task) {
+    appendAsParagraphs(ensureHint(task, id), Array.from(el.childNodes));
+  } else {
+    warn("Dropped a hint that was not inside a task.", el);
+  }
+  el.remove();
+}
+function migrateHint(el) {
+  foldIntoHint(el, el.id);
+}
+function migrateExplainer(el) {
+  warn("A task explainer became part of the task's hint, since v2 has no explainers.", el);
+  foldIntoHint(el);
+}
+function applyAnswerSolution(task, solution) {
+  const answer = Array.from(task.children).find((child) => ANSWER_TAGS.has(child.localName));
+  if (!answer || solution === void 0 || solution === null) return;
+  if (answer.localName === "webwriter-choice" && Array.isArray(solution)) {
+    const value = {};
+    for (const item of answer.querySelectorAll(":scope > webwriter-choice-item")) {
+      value[item.id] = solution.includes(item.id);
+    }
+    setSolution(answer, value);
+  } else if (answer.localName === "webwriter-order" && Array.isArray(solution)) {
+    const items = Array.from(answer.querySelectorAll(":scope > webwriter-order-item"));
+    const ordered = solution.map((id) => items.find((item) => item.id === id)).filter((item) => item !== void 0);
+    const rest = items.filter((item) => !ordered.includes(item));
+    const sorted = [...ordered, ...rest];
+    for (const item of sorted) answer.appendChild(item);
+    setSolution(
+      answer,
+      sorted.map((item) => item.id)
+    );
+  } else if (answer.localName === "webwriter-text" && typeof solution === "string") {
+    setSolution(answer, solution);
+  } else if (answer.localName === "webwriter-pairing" && !answer.hasAttribute("solution")) {
+    applyPairingSolution(answer, Array.isArray(solution) ? solution : []);
+  }
+}
+function hoistLayout(el, containerTag) {
+  const layout = el.getAttribute("layout");
+  const container = el.parentElement;
+  if (layout && container?.localName === containerTag && !container.hasAttribute("layout")) {
+    container.setAttribute("layout", layout);
+  }
+}
+function migrateChoice(el) {
+  const mode = el.getAttribute("mode") ?? "single";
+  if (mode === "truefalse") {
+    const trueFalse = createWidget("webwriter-true-false", el.id);
+    trueFalse.setAttribute("solution", "true");
+    const discarded = el.querySelectorAll(":scope > webwriter-choice-item").length;
+    el.replaceWith(trueFalse);
+    warn(
+      `A true/false question lost its solution, since v1 never stored one.${discarded ? ` ${discarded} leftover option(s) were dropped.` : ""}`,
+      trueFalse
+    );
+    return;
+  }
+  el.setAttribute("mode", mode === "multiple" ? "multiple" : "single");
+  if (el.getAttribute("layout") !== "tiles") el.removeAttribute("layout");
+  if (el.hasAttribute("randomorder")) el.setAttribute("randomize-order", "");
+  removeAttributes(el, "randomorder", "showsolution");
+  if (!el.querySelector(":scope > webwriter-choice-item")) {
+    const item = createWidget("webwriter-choice-item");
+    item.appendChild(document.createElement("p"));
+    el.appendChild(item);
+  }
+  markAsCurrent(el);
+}
+function migrateChoiceItem(el) {
+  hoistLayout(el, "webwriter-choice");
+  removeAttributes(el, "layout");
+  markAsCurrent(el);
+}
+function migrateOrder(el) {
+  if (el.getAttribute("layout") !== "tiles") el.removeAttribute("layout");
+  removeAttributes(el, "hideorderbuttons", "showsolution");
+  markAsCurrent(el);
+}
+function migrateOrderItem(el) {
+  hoistLayout(el, "webwriter-order");
+  removeAttributes(el, "layout", "draggable", "droppreview", "hideorderbuttons");
+  markAsCurrent(el);
+}
+function migrateText(el) {
+  renameAttribute(el, "freetext", "free-text");
+  renameAttribute(el, "ignorecase", "ignore-case");
+  renameAttribute(el, "wrongmessage", "wrong-message");
+  removeAttributes(el, "showsolution", "value");
+  markAsCurrent(el);
+}
+function migrateSpeech(el) {
+  removeAttributes(el, "loading", "recording");
+  markAsCurrent(el);
+}
+function isLegacyRange(value) {
+  const range = value;
+  return typeof range?.startContainer === "string" && typeof range?.startOffset === "number";
+}
+function evaluateXPath(path) {
+  try {
+    return document.evaluate(path, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+  } catch {
+    return null;
+  }
+}
+function resolveLegacyRange(legacy, scope) {
+  const start = evaluateXPath(legacy.startContainer);
+  const end = legacy.endContainer ? evaluateXPath(legacy.endContainer) : start;
+  if (!start || !end || !scope.contains(start) || !scope.contains(end)) return void 0;
+  const range = document.createRange();
+  const clamp = (node, offset) => Math.max(
+    0,
+    Math.min(offset, node.nodeType === Node.TEXT_NODE ? node.data.length : node.childNodes.length)
+  );
+  range.setStart(start, clamp(start, legacy.startOffset));
+  range.setEnd(end, clamp(end, legacy.endOffset));
+  return range;
+}
+function wordSegments(root) {
+  const segments = [];
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    const text = node;
+    for (const segment of segmenter.segment(text.data)) {
+      if (!segment.isWordLike) continue;
+      const range = document.createRange();
+      range.setStart(text, segment.index);
+      range.setEnd(text, segment.index + segment.segment.length);
+      segments.push(range);
+    }
+  }
+  return segments;
+}
+function rangesOverlap(a3, b3) {
+  return a3.compareBoundaryPoints(Range.END_TO_START, b3) < 0 && a3.compareBoundaryPoints(Range.START_TO_END, b3) > 0;
+}
+function migrateMark(el) {
+  const legacy = Array.isArray(getTaskSolution(el)) ? getTaskSolution(el) : [];
+  const ranges = legacy.filter(isLegacyRange).map((value) => resolveLegacyRange(value, el)).filter((range) => range !== void 0);
+  if (legacy.length && !ranges.length) {
+    warn("Could not locate the marked words of a task, they have to be marked again.", el);
+  }
+  for (const child of Array.from(el.querySelectorAll("br, wbr"))) {
+    if (child.localName === "br") child.replaceWith(document.createTextNode("\n"));
+    else child.remove();
+  }
+  for (let child = el.firstElementChild; child; child = el.firstElementChild) {
+    child.replaceWith(...Array.from(child.childNodes));
+  }
+  const segments = wordSegments(el);
+  const solution = segments.map((segment, index) => ranges.some((range) => rangesOverlap(range, segment)) ? index : -1).filter((index) => index !== -1);
+  removeAttributes(el, "highlighting", "value");
+  if (solution.length) setSolution(el, solution);
+  markAsCurrent(el);
+}
+function migrateCloze(el) {
+  const dragAndDrop = dragAndDropClozes.has(el);
+  const gap = retag(el, "webwriter-gap");
+  if (dragAndDrop) gap.setAttribute("mode", "drag-and-drop");
+}
+function migrateClozeGap(el) {
+  if (el.hasAttribute("showoptions")) {
+    const cloze = el.closest("webwriter-cloze");
+    if (cloze) dragAndDropClozes.add(cloze);
+  }
+  const solutions = parseJson(el.getAttribute("solution"));
+  const accepted = Array.isArray(solutions) ? solutions.filter((value) => typeof value === "string") : [];
+  if (accepted.length > 1) {
+    warn(`A gap accepted ${accepted.length} answers, v2 keeps only "${accepted[0]}".`, el);
+  }
+  if (parseJson(el.getAttribute("distraction"))) {
+    warn("A gap had distractor options, which v2 does not support. They were dropped.", el);
+  }
+  const item = createWidget("webwriter-gap-item", el.id);
+  item.textContent = accepted[0] ?? "";
+  el.replaceWith(item);
+}
+function applyPairingSolution(el, legacy) {
+  const items = Array.from(el.querySelectorAll(":scope > webwriter-pairing-item"));
+  const ids = new Set(items.map((item) => item.id));
+  const pairs = legacy.filter(
+    (entry) => Array.isArray(entry) && entry.length === 2 && entry.every((id) => typeof id === "string" && ids.has(id))
+  );
+  const paired = new Set(pairs.flat());
+  for (const item of items) {
+    if (paired.has(item.id)) continue;
+    warn("Removed a pairing item that was not part of a pair, which v2 cannot represent.", item);
+    item.remove();
+  }
+  setSolution(el, pairs);
+}
+function migratePairing(el) {
+  el.setAttribute("mode", el.getAttribute("mode") === "memory" ? "memory" : "pairing");
+  const legacy = parseJson(el.getAttribute("solution")) ?? getTaskSolution(el);
+  applyPairingSolution(el, Array.isArray(legacy) ? legacy : []);
+  markAsCurrent(el);
+}
+function migratePairingItem(el) {
+  removeAttributes(el, "draggable", "droppreview");
+  const picture = el.querySelector("picture");
+  if (picture) {
+    el.replaceChildren(picture);
+  } else {
+    const paragraph = document.createElement("p");
+    paragraph.append(...Array.from(el.childNodes));
+    for (const child of Array.from(paragraph.children)) {
+      if (child.localName === "p" || child.localName === "div") {
+        child.replaceWith(...Array.from(child.childNodes));
+      }
+    }
+    el.replaceChildren(paragraph);
+  }
+  markAsCurrent(el);
+}
+function migrateElement(el) {
+  switch (el.localName) {
+    case "webwriter-quiz":
+      return migrateQuiz(el);
+    case "webwriter-task":
+      return migrateTask(el);
+    case "webwriter-task-prompt":
+      return migratePrompt(el);
+    case "webwriter-task-hint":
+      return migrateHint(el);
+    case "webwriter-task-explainer":
+      return migrateExplainer(el);
+    case "webwriter-choice":
+      return migrateChoice(el);
+    case "webwriter-choice-item":
+      return migrateChoiceItem(el);
+    case "webwriter-order":
+      return migrateOrder(el);
+    case "webwriter-order-item":
+      return migrateOrderItem(el);
+    case "webwriter-text":
+      return migrateText(el);
+    case "webwriter-speech":
+      return migrateSpeech(el);
+    case "webwriter-mark":
+      return migrateMark(el);
+    case "webwriter-cloze":
+      return migrateCloze(el);
+    case "webwriter-cloze-gap":
+      return migrateClozeGap(el);
+    case "webwriter-pairing":
+      return migratePairing(el);
+    case "webwriter-pairing-item":
+      return migratePairingItem(el);
+    default:
+      return markAsCurrent(el);
+  }
+}
+document.addEventListener("migrate", (event) => {
+  const el = event.target;
+  if (!el?.classList) return;
+  const classes = Array.from(el.classList);
+  if (classes.find((cls) => cls.startsWith("ww-pkg-"))?.slice("ww-pkg-".length) !== name) return;
+  const major = Number.parseInt(classes.find((cls) => cls.startsWith("ww-v"))?.slice("ww-v".length) ?? "", 10);
+  if (!Number.isFinite(major) || major >= CURRENT_MAJOR_VERSION) return;
+  try {
+    migrateElement(el);
+  } catch (error) {
+    warn(`Could not migrate a <${el.localName}>, it may display incorrectly.`, el, error);
+  }
+});
+/*! Bundled license information:
+
+@lit/reactive-element/css-tag.js:
+  (**
+   * @license
+   * Copyright 2019 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+@lit/reactive-element/reactive-element.js:
+lit-html/lit-html.js:
+lit-element/lit-element.js:
+  (**
+   * @license
+   * Copyright 2017 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+
+lit-html/is-server.js:
+  (**
+   * @license
+   * Copyright 2022 Google LLC
+   * SPDX-License-Identifier: BSD-3-Clause
+   *)
+*/