@tailor-cms/ce-accordion-edit 0.0.3 → 0.0.5

package/dist/index.cjs

@@ -766,8 +766,8 @@ function getAllKeysIn$2(object2) {
 }
 var _getAllKeysIn = getAllKeysIn$2;
 var getNative$3 = _getNative, root$4 = _root;
-var DataView$1 = getNative$3(root$4, "DataView");
-var _DataView = DataView$1;
+var DataView$2 = getNative$3(root$4, "DataView");
+var _DataView = DataView$2;
 var getNative$2 = _getNative, root$3 = _root;
 var Promise$2 = getNative$2(root$3, "Promise");
 var _Promise = Promise$2;
@@ -777,12 +777,12 @@ var _Set = Set$3;
 var getNative = _getNative, root$1 = _root;
 var WeakMap$2 = getNative(root$1, "WeakMap");
 var _WeakMap = WeakMap$2;
-var DataView = _DataView, Map$1 = _Map, Promise$1 = _Promise, Set$2 = _Set, WeakMap$1 = _WeakMap, baseGetTag$3 = _baseGetTag, toSource = _toSource;
+var DataView$1 = _DataView, Map$1 = _Map, Promise$1 = _Promise, Set$2 = _Set, WeakMap$1 = _WeakMap, baseGetTag$3 = _baseGetTag, toSource = _toSource;
 var mapTag$5 = "[object Map]", objectTag$3 = "[object Object]", promiseTag = "[object Promise]", setTag$5 = "[object Set]", weakMapTag$1 = "[object WeakMap]";
 var dataViewTag$3 = "[object DataView]";
-var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$2), weakMapCtorString = toSource(WeakMap$1);
+var dataViewCtorString = toSource(DataView$1), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$2), weakMapCtorString = toSource(WeakMap$1);
 var getTag$5 = baseGetTag$3;
-if (DataView && getTag$5(new DataView(new ArrayBuffer(1))) != dataViewTag$3 || Map$1 && getTag$5(new Map$1()) != mapTag$5 || Promise$1 && getTag$5(Promise$1.resolve()) != promiseTag || Set$2 && getTag$5(new Set$2()) != setTag$5 || WeakMap$1 && getTag$5(new WeakMap$1()) != weakMapTag$1) {
+if (DataView$1 && getTag$5(new DataView$1(new ArrayBuffer(1))) != dataViewTag$3 || Map$1 && getTag$5(new Map$1()) != mapTag$5 || Promise$1 && getTag$5(Promise$1.resolve()) != promiseTag || Set$2 && getTag$5(new Set$2()) != setTag$5 || WeakMap$1 && getTag$5(new WeakMap$1()) != weakMapTag$1) {
   getTag$5 = function(value) {
     var result = baseGetTag$3(value), Ctor = result == objectTag$3 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
     if (ctorString) {
@@ -1005,6 +1005,585 @@ function cloneDeep(value) {
 }
 var cloneDeep_1 = cloneDeep;
 const cloneDeep$1 = /* @__PURE__ */ getDefaultExportFromCjs(cloneDeep_1);
+var src = {};
+var sha3$1 = {};
+var _assert = {};
+Object.defineProperty(_assert, "__esModule", { value: true });
+_assert.anumber = anumber;
+_assert.number = anumber;
+_assert.abytes = abytes;
+_assert.bytes = abytes;
+_assert.ahash = ahash;
+_assert.aexists = aexists;
+_assert.aoutput = aoutput;
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(b))
+    throw new Error("Uint8Array expected");
+  if (lengths.length > 0 && !lengths.includes(b.length))
+    throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+}
+function ahash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new Error("Hash should be wrapped by utils.wrapConstructor");
+  anumber(h.outputLen);
+  anumber(h.blockLen);
+}
+function aexists(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+const assert = {
+  number: anumber,
+  bytes: abytes,
+  hash: ahash,
+  exists: aexists,
+  output: aoutput
+};
+_assert.default = assert;
+var _u64 = {};
+Object.defineProperty(_u64, "__esModule", { value: true });
+_u64.add5L = _u64.add5H = _u64.add4H = _u64.add4L = _u64.add3H = _u64.add3L = _u64.rotlBL = _u64.rotlBH = _u64.rotlSL = _u64.rotlSH = _u64.rotr32L = _u64.rotr32H = _u64.rotrBL = _u64.rotrBH = _u64.rotrSL = _u64.rotrSH = _u64.shrSL = _u64.shrSH = _u64.toBig = void 0;
+_u64.fromBig = fromBig;
+_u64.split = split$1;
+_u64.add = add;
+const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+const _32n = /* @__PURE__ */ BigInt(32);
+function fromBig(n, le = false) {
+  if (le)
+    return { h: Number(n & U32_MASK64), l: Number(n >> _32n & U32_MASK64) };
+  return { h: Number(n >> _32n & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };
+}
+function split$1(lst, le = false) {
+  let Ah = new Uint32Array(lst.length);
+  let Al = new Uint32Array(lst.length);
+  for (let i = 0; i < lst.length; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+const toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
+_u64.toBig = toBig;
+const shrSH = (h, _l, s) => h >>> s;
+_u64.shrSH = shrSH;
+const shrSL = (h, l, s) => h << 32 - s | l >>> s;
+_u64.shrSL = shrSL;
+const rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+_u64.rotrSH = rotrSH;
+const rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+_u64.rotrSL = rotrSL;
+const rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+_u64.rotrBH = rotrBH;
+const rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+_u64.rotrBL = rotrBL;
+const rotr32H = (_h, l) => l;
+_u64.rotr32H = rotr32H;
+const rotr32L = (h, _l) => h;
+_u64.rotr32L = rotr32L;
+const rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+_u64.rotlSH = rotlSH;
+const rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+_u64.rotlSL = rotlSL;
+const rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+_u64.rotlBH = rotlBH;
+const rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+_u64.rotlBL = rotlBL;
+function add(Ah, Al, Bh, Bl) {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+_u64.add3L = add3L;
+const add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+_u64.add3H = add3H;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+_u64.add4L = add4L;
+const add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+_u64.add4H = add4H;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+_u64.add5L = add5L;
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+_u64.add5H = add5H;
+const u64 = {
+  fromBig,
+  split: split$1,
+  toBig,
+  shrSH,
+  shrSL,
+  rotrSH,
+  rotrSL,
+  rotrBH,
+  rotrBL,
+  rotr32H,
+  rotr32L,
+  rotlSH,
+  rotlSL,
+  rotlBH,
+  rotlBL,
+  add,
+  add3L,
+  add3H,
+  add4L,
+  add4H,
+  add5H,
+  add5L
+};
+_u64.default = u64;
+var utils = {};
+var crypto = {};
+Object.defineProperty(crypto, "__esModule", { value: true });
+crypto.crypto = void 0;
+crypto.crypto = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+(function(exports2) {
+  /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+  Object.defineProperty(exports2, "__esModule", { value: true });
+  exports2.Hash = exports2.nextTick = exports2.byteSwapIfBE = exports2.byteSwap = exports2.isLE = exports2.rotl = exports2.rotr = exports2.createView = exports2.u32 = exports2.u8 = void 0;
+  exports2.isBytes = isBytes2;
+  exports2.byteSwap32 = byteSwap32;
+  exports2.bytesToHex = bytesToHex;
+  exports2.hexToBytes = hexToBytes;
+  exports2.asyncLoop = asyncLoop;
+  exports2.utf8ToBytes = utf8ToBytes;
+  exports2.toBytes = toBytes;
+  exports2.concatBytes = concatBytes;
+  exports2.checkOpts = checkOpts;
+  exports2.wrapConstructor = wrapConstructor;
+  exports2.wrapConstructorWithOpts = wrapConstructorWithOpts;
+  exports2.wrapXOFConstructorWithOpts = wrapXOFConstructorWithOpts;
+  exports2.randomBytes = randomBytes;
+  const crypto_1 = crypto;
+  const _assert_js_12 = _assert;
+  function isBytes2(a) {
+    return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+  }
+  const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+  exports2.u8 = u8;
+  const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+  exports2.u32 = u32;
+  const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+  exports2.createView = createView;
+  const rotr = (word, shift2) => word << 32 - shift2 | word >>> shift2;
+  exports2.rotr = rotr;
+  const rotl = (word, shift2) => word << shift2 | word >>> 32 - shift2 >>> 0;
+  exports2.rotl = rotl;
+  exports2.isLE = (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+  const byteSwap = (word) => word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+  exports2.byteSwap = byteSwap;
+  exports2.byteSwapIfBE = exports2.isLE ? (n) => n : (n) => (0, exports2.byteSwap)(n);
+  function byteSwap32(arr) {
+    for (let i = 0; i < arr.length; i++) {
+      arr[i] = (0, exports2.byteSwap)(arr[i]);
+    }
+  }
+  const hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+  function bytesToHex(bytes) {
+    (0, _assert_js_12.abytes)(bytes);
+    let hex = "";
+    for (let i = 0; i < bytes.length; i++) {
+      hex += hexes[bytes[i]];
+    }
+    return hex;
+  }
+  const asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+  function asciiToBase16(ch) {
+    if (ch >= asciis._0 && ch <= asciis._9)
+      return ch - asciis._0;
+    if (ch >= asciis.A && ch <= asciis.F)
+      return ch - (asciis.A - 10);
+    if (ch >= asciis.a && ch <= asciis.f)
+      return ch - (asciis.a - 10);
+    return;
+  }
+  function hexToBytes(hex) {
+    if (typeof hex !== "string")
+      throw new Error("hex string expected, got " + typeof hex);
+    const hl = hex.length;
+    const al = hl / 2;
+    if (hl % 2)
+      throw new Error("hex string expected, got unpadded hex of length " + hl);
+    const array2 = new Uint8Array(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+      const n1 = asciiToBase16(hex.charCodeAt(hi));
+      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+      if (n1 === void 0 || n2 === void 0) {
+        const char = hex[hi] + hex[hi + 1];
+        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+      }
+      array2[ai] = n1 * 16 + n2;
+    }
+    return array2;
+  }
+  const nextTick = async () => {
+  };
+  exports2.nextTick = nextTick;
+  async function asyncLoop(iters, tick, cb) {
+    let ts = Date.now();
+    for (let i = 0; i < iters; i++) {
+      cb(i);
+      const diff = Date.now() - ts;
+      if (diff >= 0 && diff < tick)
+        continue;
+      await (0, exports2.nextTick)();
+      ts += diff;
+    }
+  }
+  function utf8ToBytes(str) {
+    if (typeof str !== "string")
+      throw new Error("utf8ToBytes expected string, got " + typeof str);
+    return new Uint8Array(new TextEncoder().encode(str));
+  }
+  function toBytes(data) {
+    if (typeof data === "string")
+      data = utf8ToBytes(data);
+    (0, _assert_js_12.abytes)(data);
+    return data;
+  }
+  function concatBytes(...arrays) {
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      (0, _assert_js_12.abytes)(a);
+      sum += a.length;
+    }
+    const res = new Uint8Array(sum);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      res.set(a, pad);
+      pad += a.length;
+    }
+    return res;
+  }
+  class Hash2 {
+    // Safe version that clones internal state
+    clone() {
+      return this._cloneInto();
+    }
+  }
+  exports2.Hash = Hash2;
+  function checkOpts(defaults2, opts) {
+    if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]")
+      throw new Error("Options should be object or undefined");
+    const merged = Object.assign(defaults2, opts);
+    return merged;
+  }
+  function wrapConstructor(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+    const tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashCons();
+    return hashC;
+  }
+  function wrapConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+  }
+  function wrapXOFConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+  }
+  function randomBytes(bytesLength = 32) {
+    if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === "function") {
+      return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+    }
+    if (crypto_1.crypto && typeof crypto_1.crypto.randomBytes === "function") {
+      return crypto_1.crypto.randomBytes(bytesLength);
+    }
+    throw new Error("crypto.getRandomValues must be defined");
+  }
+})(utils);
+Object.defineProperty(sha3$1, "__esModule", { value: true });
+sha3$1.shake256 = sha3$1.shake128 = sha3$1.keccak_512 = sha3$1.keccak_384 = sha3$1.keccak_256 = sha3$1.keccak_224 = sha3$1.sha3_512 = sha3$1.sha3_384 = sha3$1.sha3_256 = sha3$1.sha3_224 = sha3$1.Keccak = void 0;
+sha3$1.keccakP = keccakP;
+const _assert_js_1 = _assert;
+const _u64_js_1 = _u64;
+const utils_js_1 = utils;
+const SHA3_PI = [];
+const SHA3_ROTL = [];
+const _SHA3_IOTA = [];
+const _0n = /* @__PURE__ */ BigInt(0);
+const _1n = /* @__PURE__ */ BigInt(1);
+const _2n = /* @__PURE__ */ BigInt(2);
+const _7n = /* @__PURE__ */ BigInt(7);
+const _256n = /* @__PURE__ */ BigInt(256);
+const _0x71n = /* @__PURE__ */ BigInt(113);
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+  [x, y] = [y, (2 * x + 3 * y) % 5];
+  SHA3_PI.push(2 * (5 * y + x));
+  SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+  let t = _0n;
+  for (let j = 0; j < 7; j++) {
+    R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+    if (R & _2n)
+      t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
+  }
+  _SHA3_IOTA.push(t);
+}
+const [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ (0, _u64_js_1.split)(_SHA3_IOTA, true);
+const rotlH = (h, l, s) => s > 32 ? (0, _u64_js_1.rotlBH)(h, l, s) : (0, _u64_js_1.rotlSH)(h, l, s);
+const rotlL = (h, l, s) => s > 32 ? (0, _u64_js_1.rotlBL)(h, l, s) : (0, _u64_js_1.rotlSL)(h, l, s);
+function keccakP(s, rounds = 24) {
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift2 = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift2);
+      const Tl = rotlL(curH, curL, shift2);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0; x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  B.fill(0);
+}
+class Keccak extends utils_js_1.Hash {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+    super();
+    this.blockLen = blockLen;
+    this.suffix = suffix;
+    this.outputLen = outputLen;
+    this.enableXOF = enableXOF;
+    this.rounds = rounds;
+    this.pos = 0;
+    this.posOut = 0;
+    this.finished = false;
+    this.destroyed = false;
+    (0, _assert_js_1.anumber)(outputLen);
+    if (0 >= this.blockLen || this.blockLen >= 200)
+      throw new Error("Sha3 supports only keccak-f1600 function");
+    this.state = new Uint8Array(200);
+    this.state32 = (0, utils_js_1.u32)(this.state);
+  }
+  keccak() {
+    if (!utils_js_1.isLE)
+      (0, utils_js_1.byteSwap32)(this.state32);
+    keccakP(this.state32, this.rounds);
+    if (!utils_js_1.isLE)
+      (0, utils_js_1.byteSwap32)(this.state32);
+    this.posOut = 0;
+    this.pos = 0;
+  }
+  update(data) {
+    (0, _assert_js_1.aexists)(this);
+    const { blockLen, state } = this;
+    data = (0, utils_js_1.toBytes)(data);
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      for (let i = 0; i < take; i++)
+        state[this.pos++] ^= data[pos++];
+      if (this.pos === blockLen)
+        this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = true;
+    const { state, suffix, pos, blockLen } = this;
+    state[pos] ^= suffix;
+    if ((suffix & 128) !== 0 && pos === blockLen - 1)
+      this.keccak();
+    state[blockLen - 1] ^= 128;
+    this.keccak();
+  }
+  writeInto(out) {
+    (0, _assert_js_1.aexists)(this, false);
+    (0, _assert_js_1.abytes)(out);
+    this.finish();
+    const bufferOut = this.state;
+    const { blockLen } = this;
+    for (let pos = 0, len = out.length; pos < len; ) {
+      if (this.posOut >= blockLen)
+        this.keccak();
+      const take = Math.min(blockLen - this.posOut, len - pos);
+      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+      this.posOut += take;
+      pos += take;
+    }
+    return out;
+  }
+  xofInto(out) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(out);
+  }
+  xof(bytes) {
+    (0, _assert_js_1.anumber)(bytes);
+    return this.xofInto(new Uint8Array(bytes));
+  }
+  digestInto(out) {
+    (0, _assert_js_1.aoutput)(out, this);
+    if (this.finished)
+      throw new Error("digest() was already called");
+    this.writeInto(out);
+    this.destroy();
+    return out;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = true;
+    this.state.fill(0);
+  }
+  _cloneInto(to) {
+    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+    to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+    to.state32.set(this.state32);
+    to.pos = this.pos;
+    to.posOut = this.posOut;
+    to.finished = this.finished;
+    to.rounds = rounds;
+    to.suffix = suffix;
+    to.outputLen = outputLen;
+    to.enableXOF = enableXOF;
+    to.destroyed = this.destroyed;
+    return to;
+  }
+}
+sha3$1.Keccak = Keccak;
+const gen = (suffix, blockLen, outputLen) => (0, utils_js_1.wrapConstructor)(() => new Keccak(blockLen, suffix, outputLen));
+sha3$1.sha3_224 = gen(6, 144, 224 / 8);
+sha3$1.sha3_256 = gen(6, 136, 256 / 8);
+sha3$1.sha3_384 = gen(6, 104, 384 / 8);
+sha3$1.sha3_512 = gen(6, 72, 512 / 8);
+sha3$1.keccak_224 = gen(1, 144, 224 / 8);
+sha3$1.keccak_256 = gen(1, 136, 256 / 8);
+sha3$1.keccak_384 = gen(1, 104, 384 / 8);
+sha3$1.keccak_512 = gen(1, 72, 512 / 8);
+const genShake = (suffix, blockLen, outputLen) => (0, utils_js_1.wrapXOFConstructorWithOpts)((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === void 0 ? outputLen : opts.dkLen, true));
+sha3$1.shake128 = genShake(31, 168, 128 / 8);
+sha3$1.shake256 = genShake(31, 136, 256 / 8);
+const { sha3_512: sha3 } = sha3$1;
+const defaultLength = 24;
+const bigLength = 32;
+const createEntropy = (length = 4, random = Math.random) => {
+  let entropy = "";
+  while (entropy.length < length) {
+    entropy = entropy + Math.floor(random() * 36).toString(36);
+  }
+  return entropy;
+};
+function bufToBigInt(buf) {
+  let bits = 8n;
+  let value = 0n;
+  for (const i of buf.values()) {
+    const bi = BigInt(i);
+    value = (value << bits) + bi;
+  }
+  return value;
+}
+const hash = (input = "") => {
+  return bufToBigInt(sha3(input)).toString(36).slice(1);
+};
+const alphabet = Array.from(
+  { length: 26 },
+  (x, i) => String.fromCharCode(i + 97)
+);
+const randomLetter = (random) => alphabet[Math.floor(random() * alphabet.length)];
+const createFingerprint = ({
+  globalObj = typeof commonjsGlobal !== "undefined" ? commonjsGlobal : typeof window !== "undefined" ? window : {},
+  random = Math.random
+} = {}) => {
+  const globals = Object.keys(globalObj).toString();
+  const sourceString = globals.length ? globals + createEntropy(bigLength, random) : createEntropy(bigLength, random);
+  return hash(sourceString).substring(0, bigLength);
+};
+const createCounter = (count) => () => {
+  return count++;
+};
+const initialCountMax = 476782367;
+const init$1 = ({
+  // Fallback if the user does not pass in a CSPRNG. This should be OK
+  // because we don't rely solely on the random number generator for entropy.
+  // We also use the host fingerprint, current time, and a session counter.
+  random = Math.random,
+  counter = createCounter(Math.floor(random() * initialCountMax)),
+  length = defaultLength,
+  fingerprint = createFingerprint({ random })
+} = {}) => {
+  return function cuid2() {
+    const firstLetter = randomLetter(random);
+    const time = Date.now().toString(36);
+    const count = counter().toString(36);
+    const salt = createEntropy(length, random);
+    const hashInput = `${time + salt + count + fingerprint}`;
+    return `${firstLetter + hash(hashInput).substring(1, length)}`;
+  };
+};
+const createId$1 = init$1();
+const isCuid$1 = (id, { minLength = 2, maxLength = bigLength } = {}) => {
+  const length = id.length;
+  const regex2 = /^[0-9a-z]+$/;
+  try {
+    if (typeof id === "string" && length >= minLength && length <= maxLength && regex2.test(id))
+      return true;
+  } finally {
+  }
+  return false;
+};
+src.getConstants = () => ({ defaultLength, bigLength });
+src.init = init$1;
+src.createId = createId$1;
+src.bufToBigInt = bufToBigInt;
+src.createCounter = createCounter;
+src.createFingerprint = createFingerprint;
+src.isCuid = isCuid$1;
+const { createId, init, getConstants, isCuid } = src;
+var createId_1 = createId;
 const _export_sfc = (sfc, props2) => {
   const target = sfc.__vccOpts || sfc;
   for (const [key, val] of props2) {
@@ -2578,40 +3157,40 @@ class ReferenceSet extends Set {
     return next;
   }
 }
-function clone$2(src, seen = /* @__PURE__ */ new Map()) {
-  if (isSchema(src) || !src || typeof src !== "object")
-    return src;
-  if (seen.has(src))
-    return seen.get(src);
+function clone$2(src2, seen = /* @__PURE__ */ new Map()) {
+  if (isSchema(src2) || !src2 || typeof src2 !== "object")
+    return src2;
+  if (seen.has(src2))
+    return seen.get(src2);
   let copy2;
-  if (src instanceof Date) {
-    copy2 = new Date(src.getTime());
-    seen.set(src, copy2);
-  } else if (src instanceof RegExp) {
-    copy2 = new RegExp(src);
-    seen.set(src, copy2);
-  } else if (Array.isArray(src)) {
-    copy2 = new Array(src.length);
-    seen.set(src, copy2);
-    for (let i = 0; i < src.length; i++)
-      copy2[i] = clone$2(src[i], seen);
-  } else if (src instanceof Map) {
+  if (src2 instanceof Date) {
+    copy2 = new Date(src2.getTime());
+    seen.set(src2, copy2);
+  } else if (src2 instanceof RegExp) {
+    copy2 = new RegExp(src2);
+    seen.set(src2, copy2);
+  } else if (Array.isArray(src2)) {
+    copy2 = new Array(src2.length);
+    seen.set(src2, copy2);
+    for (let i = 0; i < src2.length; i++)
+      copy2[i] = clone$2(src2[i], seen);
+  } else if (src2 instanceof Map) {
     copy2 = /* @__PURE__ */ new Map();
-    seen.set(src, copy2);
-    for (const [k, v] of src.entries())
+    seen.set(src2, copy2);
+    for (const [k, v] of src2.entries())
       copy2.set(k, clone$2(v, seen));
-  } else if (src instanceof Set) {
+  } else if (src2 instanceof Set) {
     copy2 = /* @__PURE__ */ new Set();
-    seen.set(src, copy2);
-    for (const v of src)
+    seen.set(src2, copy2);
+    for (const v of src2)
       copy2.add(clone$2(v, seen));
-  } else if (src instanceof Object) {
+  } else if (src2 instanceof Object) {
     copy2 = {};
-    seen.set(src, copy2);
-    for (const [k, v] of Object.entries(src))
+    seen.set(src2, copy2);
+    for (const [k, v] of Object.entries(src2))
       copy2[k] = clone$2(v, seen);
   } else {
-    throw Error(`Unable to clone ${src}`);
+    throw Error(`Unable to clone ${src2}`);
   }
   return copy2;
 }
@@ -4068,11 +4647,11 @@ function getParentAutoScrollElement$1(el, includeSelf) {
   } while (elem = elem.parentNode);
   return getWindowScrollingElement$1();
 }
-function extend$1(dst, src) {
-  if (dst && src) {
-    for (var key in src) {
-      if (src.hasOwnProperty(key)) {
-        dst[key] = src[key];
+function extend$1(dst, src2) {
+  if (dst && src2) {
+    for (var key in src2) {
+      if (src2.hasOwnProperty(key)) {
+        dst[key] = src2[key];
       }
     }
   }
@@ -9840,10 +10419,10 @@ class DOMSerializer {
         while (keep < active.length)
           top = active.pop()[1];
         while (rendered < node.marks.length) {
-          let add = node.marks[rendered++];
-          let markDOM = this.serializeMark(add, node.isInline, options);
+          let add2 = node.marks[rendered++];
+          let markDOM = this.serializeMark(add2, node.isInline, options);
           if (markDOM) {
-            active.push([add, top]);
+            active.push([add2, top]);
             top.appendChild(markDOM.dom);
             top = markDOM.contentDOM || markDOM.dom;
           }
@@ -10974,11 +11553,11 @@ class Fitter {
         this.openFrontierNode(wrap[i]);
     let slice2 = this.unplaced, fragment = parent2 ? parent2.content : slice2.content;
     let openStart = slice2.openStart - sliceDepth;
-    let taken = 0, add = [];
+    let taken = 0, add2 = [];
     let { match, type: type2 } = this.frontier[frontierDepth];
     if (inject) {
       for (let i = 0; i < inject.childCount; i++)
-        add.push(inject.child(i));
+        add2.push(inject.child(i));
       match = match.matchFragment(inject);
     }
     let openEndCount = fragment.size + sliceDepth - (slice2.content.size - slice2.openEnd);
@@ -10989,13 +11568,13 @@ class Fitter {
       taken++;
       if (taken > 1 || openStart == 0 || next.content.size) {
         match = matches2;
-        add.push(closeNodeStart(next.mark(type2.allowedMarks(next.marks)), taken == 1 ? openStart : 0, taken == fragment.childCount ? openEndCount : -1));
+        add2.push(closeNodeStart(next.mark(type2.allowedMarks(next.marks)), taken == 1 ? openStart : 0, taken == fragment.childCount ? openEndCount : -1));
       }
     }
     let toEnd = taken == fragment.childCount;
     if (!toEnd)
       openEndCount = -1;
-    this.placed = addToFragment(this.placed, frontierDepth, Fragment.from(add));
+    this.placed = addToFragment(this.placed, frontierDepth, Fragment.from(add2));
     this.frontier[frontierDepth].match = match;
     if (toEnd && openEndCount < 0 && parent2 && parent2.type == this.frontier[this.depth].type && this.frontier.length > 1)
       this.closeFrontierNode();
@@ -11044,8 +11623,8 @@ class Fitter {
       this.placed = addToFragment(this.placed, close2.depth, close2.fit);
     $to = close2.move;
     for (let d = close2.depth + 1; d <= $to.depth; d++) {
-      let node = $to.node(d), add = node.type.contentMatch.fillBefore(node.content, true, $to.index(d));
-      this.openFrontierNode(node.type, node.attrs, add);
+      let node = $to.node(d), add2 = node.type.contentMatch.fillBefore(node.content, true, $to.index(d));
+      this.openFrontierNode(node.type, node.attrs, add2);
     }
     return $to;
   }
@@ -11057,9 +11636,9 @@ class Fitter {
   }
   closeFrontierNode() {
     let open = this.frontier.pop();
-    let add = open.match.fillBefore(Fragment.empty, true);
-    if (add.childCount)
-      this.placed = addToFragment(this.placed, this.frontier.length, add);
+    let add2 = open.match.fillBefore(Fragment.empty, true);
+    if (add2.childCount)
+      this.placed = addToFragment(this.placed, this.frontier.length, add2);
   }
 }
 function dropFromFragment(fragment, depth, count) {
@@ -24125,7 +24704,7 @@ lodash.exports;
         var id = ++idCounter2;
         return toString2(prefix) + id;
       }
-      var add = createMathOperation(function(augend, addend) {
+      var add2 = createMathOperation(function(augend, addend) {
         return augend + addend;
       }, 0);
       var ceil = createRound("ceil");
@@ -24318,7 +24897,7 @@ lodash.exports;
       lodash2.extend = assignIn;
       lodash2.extendWith = assignInWith;
       mixin(lodash2, lodash2);
-      lodash2.add = add;
+      lodash2.add = add2;
       lodash2.attempt = attempt;
       lodash2.camelCase = camelCase;
       lodash2.capitalize = capitalize;
@@ -25072,11 +25651,11 @@ function getParentAutoScrollElement(el, includeSelf) {
   } while (elem = elem.parentNode);
   return getWindowScrollingElement();
 }
-function extend(dst, src) {
-  if (dst && src) {
-    for (var key in src) {
-      if (src.hasOwnProperty(key)) {
-        dst[key] = src[key];
+function extend(dst, src2) {
+  if (dst && src2) {
+    for (var key in src2) {
+      if (src2.hasOwnProperty(key)) {
+        dst[key] = src2[key];
       }
     }
   }
@@ -26884,43 +27463,6 @@ _extends(Remove, {
 });
 Sortable.mount(new AutoScrollPlugin());
 Sortable.mount(Remove, Revert);
-const byteToHex = [];
-for (let i = 0; i < 256; ++i) {
-  byteToHex.push((i + 256).toString(16).slice(1));
-}
-function unsafeStringify(arr, offset = 0) {
-  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
-}
-let getRandomValues;
-const rnds8 = new Uint8Array(16);
-function rng() {
-  if (!getRandomValues) {
-    if (typeof crypto === "undefined" || !crypto.getRandomValues) {
-      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
-    }
-    getRandomValues = crypto.getRandomValues.bind(crypto);
-  }
-  return getRandomValues(rnds8);
-}
-const randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-const native = { randomUUID };
-function v4(options, buf, offset) {
-  if (native.randomUUID && !buf && !options) {
-    return native.randomUUID();
-  }
-  options = options || {};
-  const rnds = options.random || (options.rng || rng)();
-  rnds[6] = rnds[6] & 15 | 64;
-  rnds[8] = rnds[8] & 63 | 128;
-  if (buf) {
-    offset = offset || 0;
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
-    }
-    return buf;
-  }
-  return unsafeStringify(rnds);
-}
 var baseKeys = _baseKeys, getTag = _getTag, isArguments = isArguments_1, isArray = isArray_1, isArrayLike = isArrayLike_1, isBuffer = isBufferExports, isPrototype = _isPrototype, isTypedArray = isTypedArray_1;
 var mapTag = "[object Map]", setTag = "[object Set]";
 var objectProto = Object.prototype;
@@ -26960,25 +27502,22 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
   __name: "AccordionItem",
   props: {
     item: {},
-    embedTypes: {},
+    allowedEmbedTypes: {},
     embeds: { default: () => {
     } },
     isFocused: { type: Boolean, default: false },
     isDisabled: { type: Boolean, default: false },
     isExpanded: { type: Boolean, default: false }
   },
-  emits: ["save", "expand", "delete"],
+  emits: ["save", "delete"],
   setup(__props, { emit: emit2 }) {
     const props2 = __props;
     const eventBus = vue.inject("$eventBus");
     const isEditing = vue.ref(!props2.item.title);
     const form = vue.ref();
     const title = vue.ref(props2.item.title);
-    const isNew = vue.computed(() => !props2.item.title);
     const hasElements = vue.computed(() => !isEmpty$1(props2.embeds));
     const cancel = () => {
-      if (isNew.value)
-        return emit2("delete");
       title.value = props2.item.title;
       isEditing.value = false;
     };
@@ -26990,8 +27529,6 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
       isEditing.value = false;
       const item = { ...props2.item, title: title.value };
       emit2("save", { item, embeds: props2.embeds });
-      if (isNew.value)
-        emit2("expand");
     };
     const saveEmbed = (embeds) => {
       const item = cloneDeep$1(props2.item);
@@ -27022,13 +27559,11 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
       const _component_VExpansionPanelTitle = vue.resolveComponent("VExpansionPanelTitle");
       const _component_VHover = vue.resolveComponent("VHover");
       const _component_VAlert = vue.resolveComponent("VAlert");
-      const _component_EmbeddedContainer = vue.resolveComponent("EmbeddedContainer");
+      const _component_TailorEmbeddedContainer = vue.resolveComponent("TailorEmbeddedContainer");
       const _component_VExpansionPanelText = vue.resolveComponent("VExpansionPanelText");
       const _component_VExpansionPanel = vue.resolveComponent("VExpansionPanel");
       const _directive_tooltip = vue.resolveDirective("tooltip");
       return vue.openBlock(), vue.createBlock(_component_VExpansionPanel, {
-        "hide-actions": isNew.value,
-        readonly: isNew.value,
         value: _ctx.item.id
       }, {
         default: vue.withCtx(() => [
@@ -27037,7 +27572,7 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
               vue.createVNode(_component_VExpansionPanelTitle, vue.mergeProps(hoverProps, {
                 class: "pa-2 pr-4",
                 color: "primary-lighten-5",
-                "min-height": "56"
+                "min-height": "64"
               }), {
                 default: vue.withCtx(() => [
                   vue.createVNode(_component_VForm, {
@@ -27145,10 +27680,10 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
                 ]),
                 _: 1
               })) : vue.createCommentVNode("", true),
-              vue.createVNode(_component_EmbeddedContainer, {
+              vue.createVNode(_component_TailorEmbeddedContainer, {
                 container: { embeds: _ctx.embeds },
                 "is-disabled": _ctx.isDisabled,
-                types: _ctx.embedTypes,
+                types: _ctx.allowedEmbedTypes,
                 onDelete: deleteEmbed,
                 onSave: _cache[6] || (_cache[6] = ($event) => saveEmbed($event.embeds))
               }, null, 8, ["container", "is-disabled", "types"])
@@ -27157,18 +27692,18 @@ const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
           })
         ]),
         _: 1
-      }, 8, ["hide-actions", "readonly", "value"]);
+      }, 8, ["value"]);
     };
   }
 });
-const AccordionItem_vue_vue_type_style_index_0_scoped_9017ba29_lang = "";
-const AccordionItem = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-9017ba29"]]);
+const AccordionItem_vue_vue_type_style_index_0_scoped_2e9fbd32_lang = "";
+const AccordionItem = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["__scopeId", "data-v-2e9fbd32"]]);
 const _hoisted_1 = { class: "tce-accordion d-flex flex-column align-center text-center" };
 const _sfc_main = /* @__PURE__ */ vue.defineComponent({
   __name: "Edit",
   props: {
     element: {},
-    embedTypes: {},
+    allowedEmbedTypes: {},
     isFocused: { type: Boolean },
     isDisabled: { type: Boolean }
   },
@@ -27185,9 +27720,11 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
         return acc;
       }, {})
     );
-    const add = () => {
-      const id = v4();
-      elementData.items.push({ id, elementIds: [] });
+    const add2 = () => {
+      const id = createId_1();
+      elementData.items.push({ id, title: "Title", elementIds: [] });
+      expanded.value.push(id);
+      emit2("save", elementData);
     };
     const saveItem = ({ item, embeds = {} }, index2) => {
       elementData.items[index2] = item;
@@ -27229,7 +27766,6 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
           ref: panels,
           modelValue: expanded.value,
           "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => expanded.value = $event),
-          elevation: "0",
           rounded: "lg",
           multiple: ""
         }, {
@@ -27242,7 +27778,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
                 (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(elementData.items, (item, index2) => {
                   return vue.openBlock(), vue.createBlock(AccordionItem, {
                     key: item.id,
-                    "embed-types": _ctx.embedTypes,
+                    "allowed-embed-types": _ctx.allowedEmbedTypes,
                     embeds: embedsByItem.value[item.id],
                     "is-disabled": _ctx.isDisabled,
                     "is-expanded": expanded.value.includes(item.id),
@@ -27251,7 +27787,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
                     onDelete: ($event) => deleteItem(item.id, index2),
                     onExpand: ($event) => expanded.value.push(item.id),
                     onSave: ($event) => saveItem($event, index2)
-                  }, null, 8, ["embed-types", "embeds", "is-disabled", "is-expanded", "is-focused", "item", "onDelete", "onExpand", "onSave"]);
+                  }, null, 8, ["allowed-embed-types", "embeds", "is-disabled", "is-expanded", "is-focused", "item", "onDelete", "onExpand", "onSave"]);
                 }), 128))
               ]),
               _: 1
@@ -27274,7 +27810,7 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
           color: "primary-darken-4",
           "prepend-icon": "mdi-plus",
           variant: "text",
-          onClick: add
+          onClick: add2
         }, {
           default: vue.withCtx(() => [
             vue.createTextVNode(" Add accordion item ")
@@ -27285,8 +27821,8 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     };
   }
 });
-const Edit_vue_vue_type_style_index_0_scoped_227b8d13_lang = "";
-const Edit = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-227b8d13"]]);
+const Edit_vue_vue_type_style_index_0_scoped_b6deefb4_lang = "";
+const Edit = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-b6deefb4"]]);
 const manifest = {
   ...src_default,
   Edit