n8n-editor-ui 1.75.1 → 1.77.0

package/dist/assets/{polyfills-BN5TIqPj.js → polyfills-DNwgos9f.js}

@@ -5983,3 +5983,653 @@ function requireWeb_urlSearchParams_size () {
 }
 
 requireWeb_urlSearchParams_size();
+
+var web_structuredClone = {};
+
+var isConstructor;
+var hasRequiredIsConstructor;
+
+function requireIsConstructor () {
+	if (hasRequiredIsConstructor) return isConstructor;
+	hasRequiredIsConstructor = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+	var fails = requireFails();
+	var isCallable = requireIsCallable();
+	var classof = requireClassof();
+	var getBuiltIn = requireGetBuiltIn();
+	var inspectSource = requireInspectSource();
+
+	var noop = function () { /* empty */ };
+	var construct = getBuiltIn('Reflect', 'construct');
+	var constructorRegExp = /^\s*(?:class|function)\b/;
+	var exec = uncurryThis(constructorRegExp.exec);
+	var INCORRECT_TO_STRING = !constructorRegExp.test(noop);
+
+	var isConstructorModern = function isConstructor(argument) {
+	  if (!isCallable(argument)) return false;
+	  try {
+	    construct(noop, [], argument);
+	    return true;
+	  } catch (error) {
+	    return false;
+	  }
+	};
+
+	var isConstructorLegacy = function isConstructor(argument) {
+	  if (!isCallable(argument)) return false;
+	  switch (classof(argument)) {
+	    case 'AsyncFunction':
+	    case 'GeneratorFunction':
+	    case 'AsyncGeneratorFunction': return false;
+	  }
+	  try {
+	    // we can't check .prototype since constructors produced by .bind haven't it
+	    // `Function#toString` throws on some built-it function in some legacy engines
+	    // (for example, `DOMQuad` and similar in FF41-)
+	    return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
+	  } catch (error) {
+	    return true;
+	  }
+	};
+
+	isConstructorLegacy.sham = true;
+
+	// `IsConstructor` abstract operation
+	// https://tc39.es/ecma262/#sec-isconstructor
+	isConstructor = !construct || fails(function () {
+	  var called;
+	  return isConstructorModern(isConstructorModern.call)
+	    || !isConstructorModern(Object)
+	    || !isConstructorModern(function () { called = true; })
+	    || called;
+	}) ? isConstructorLegacy : isConstructorModern;
+	return isConstructor;
+}
+
+var regexpGetFlags;
+var hasRequiredRegexpGetFlags;
+
+function requireRegexpGetFlags () {
+	if (hasRequiredRegexpGetFlags) return regexpGetFlags;
+	hasRequiredRegexpGetFlags = 1;
+	var call = requireFunctionCall();
+	var hasOwn = requireHasOwnProperty();
+	var isPrototypeOf = requireObjectIsPrototypeOf();
+	var regExpFlags = requireRegexpFlags();
+
+	var RegExpPrototype = RegExp.prototype;
+
+	regexpGetFlags = function (R) {
+	  var flags = R.flags;
+	  return flags === undefined && !('flags' in RegExpPrototype) && !hasOwn(R, 'flags') && isPrototypeOf(RegExpPrototype, R)
+	    ? call(regExpFlags, R) : flags;
+	};
+	return regexpGetFlags;
+}
+
+var mapHelpers;
+var hasRequiredMapHelpers;
+
+function requireMapHelpers () {
+	if (hasRequiredMapHelpers) return mapHelpers;
+	hasRequiredMapHelpers = 1;
+	var uncurryThis = requireFunctionUncurryThis();
+
+	// eslint-disable-next-line es/no-map -- safe
+	var MapPrototype = Map.prototype;
+
+	mapHelpers = {
+	  // eslint-disable-next-line es/no-map -- safe
+	  Map: Map,
+	  set: uncurryThis(MapPrototype.set),
+	  get: uncurryThis(MapPrototype.get),
+	  has: uncurryThis(MapPrototype.has),
+	  remove: uncurryThis(MapPrototype['delete']),
+	  proto: MapPrototype
+	};
+	return mapHelpers;
+}
+
+var hasRequiredWeb_structuredClone;
+
+function requireWeb_structuredClone () {
+	if (hasRequiredWeb_structuredClone) return web_structuredClone;
+	hasRequiredWeb_structuredClone = 1;
+	var IS_PURE = requireIsPure();
+	var $ = require_export();
+	var globalThis = requireGlobalThis();
+	var getBuiltIn = requireGetBuiltIn();
+	var uncurryThis = requireFunctionUncurryThis();
+	var fails = requireFails();
+	var uid = requireUid();
+	var isCallable = requireIsCallable();
+	var isConstructor = requireIsConstructor();
+	var isNullOrUndefined = requireIsNullOrUndefined();
+	var isObject = requireIsObject();
+	var isSymbol = requireIsSymbol();
+	var iterate = requireIterate();
+	var anObject = requireAnObject();
+	var classof = requireClassof();
+	var hasOwn = requireHasOwnProperty();
+	var createProperty = requireCreateProperty();
+	var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
+	var lengthOfArrayLike = requireLengthOfArrayLike();
+	var validateArgumentsLength = requireValidateArgumentsLength();
+	var getRegExpFlags = requireRegexpGetFlags();
+	var MapHelpers = requireMapHelpers();
+	var SetHelpers = requireSetHelpers();
+	var setIterate = requireSetIterate();
+	var detachTransferable = requireDetachTransferable();
+	var ERROR_STACK_INSTALLABLE = requireErrorStackInstallable();
+	var PROPER_STRUCTURED_CLONE_TRANSFER = requireStructuredCloneProperTransfer();
+
+	var Object = globalThis.Object;
+	var Array = globalThis.Array;
+	var Date = globalThis.Date;
+	var Error = globalThis.Error;
+	var TypeError = globalThis.TypeError;
+	var PerformanceMark = globalThis.PerformanceMark;
+	var DOMException = getBuiltIn('DOMException');
+	var Map = MapHelpers.Map;
+	var mapHas = MapHelpers.has;
+	var mapGet = MapHelpers.get;
+	var mapSet = MapHelpers.set;
+	var Set = SetHelpers.Set;
+	var setAdd = SetHelpers.add;
+	var setHas = SetHelpers.has;
+	var objectKeys = getBuiltIn('Object', 'keys');
+	var push = uncurryThis([].push);
+	var thisBooleanValue = uncurryThis(true.valueOf);
+	var thisNumberValue = uncurryThis(1.0.valueOf);
+	var thisStringValue = uncurryThis(''.valueOf);
+	var thisTimeValue = uncurryThis(Date.prototype.getTime);
+	var PERFORMANCE_MARK = uid('structuredClone');
+	var DATA_CLONE_ERROR = 'DataCloneError';
+	var TRANSFERRING = 'Transferring';
+
+	var checkBasicSemantic = function (structuredCloneImplementation) {
+	  return !fails(function () {
+	    var set1 = new globalThis.Set([7]);
+	    var set2 = structuredCloneImplementation(set1);
+	    var number = structuredCloneImplementation(Object(7));
+	    return set2 === set1 || !set2.has(7) || !isObject(number) || +number !== 7;
+	  }) && structuredCloneImplementation;
+	};
+
+	var checkErrorsCloning = function (structuredCloneImplementation, $Error) {
+	  return !fails(function () {
+	    var error = new $Error();
+	    var test = structuredCloneImplementation({ a: error, b: error });
+	    return !(test && test.a === test.b && test.a instanceof $Error && test.a.stack === error.stack);
+	  });
+	};
+
+	// https://github.com/whatwg/html/pull/5749
+	var checkNewErrorsCloningSemantic = function (structuredCloneImplementation) {
+	  return !fails(function () {
+	    var test = structuredCloneImplementation(new globalThis.AggregateError([1], PERFORMANCE_MARK, { cause: 3 }));
+	    return test.name !== 'AggregateError' || test.errors[0] !== 1 || test.message !== PERFORMANCE_MARK || test.cause !== 3;
+	  });
+	};
+
+	// FF94+, Safari 15.4+, Chrome 98+, NodeJS 17.0+, Deno 1.13+
+	// FF<103 and Safari implementations can't clone errors
+	// https://bugzilla.mozilla.org/show_bug.cgi?id=1556604
+	// FF103 can clone errors, but `.stack` of clone is an empty string
+	// https://bugzilla.mozilla.org/show_bug.cgi?id=1778762
+	// FF104+ fixed it on usual errors, but not on DOMExceptions
+	// https://bugzilla.mozilla.org/show_bug.cgi?id=1777321
+	// Chrome <102 returns `null` if cloned object contains multiple references to one error
+	// https://bugs.chromium.org/p/v8/issues/detail?id=12542
+	// NodeJS implementation can't clone DOMExceptions
+	// https://github.com/nodejs/node/issues/41038
+	// only FF103+ supports new (html/5749) error cloning semantic
+	var nativeStructuredClone = globalThis.structuredClone;
+
+	var FORCED_REPLACEMENT = IS_PURE
+	  || !checkErrorsCloning(nativeStructuredClone, Error)
+	  || !checkErrorsCloning(nativeStructuredClone, DOMException)
+	  || !checkNewErrorsCloningSemantic(nativeStructuredClone);
+
+	// Chrome 82+, Safari 14.1+, Deno 1.11+
+	// Chrome 78-81 implementation swaps `.name` and `.message` of cloned `DOMException`
+	// Chrome returns `null` if cloned object contains multiple references to one error
+	// Safari 14.1 implementation doesn't clone some `RegExp` flags, so requires a workaround
+	// Safari implementation can't clone errors
+	// Deno 1.2-1.10 implementations too naive
+	// NodeJS 16.0+ does not have `PerformanceMark` constructor
+	// NodeJS <17.2 structured cloning implementation from `performance.mark` is too naive
+	// and can't clone, for example, `RegExp` or some boxed primitives
+	// https://github.com/nodejs/node/issues/40840
+	// no one of those implementations supports new (html/5749) error cloning semantic
+	var structuredCloneFromMark = !nativeStructuredClone && checkBasicSemantic(function (value) {
+	  return new PerformanceMark(PERFORMANCE_MARK, { detail: value }).detail;
+	});
+
+	var nativeRestrictedStructuredClone = checkBasicSemantic(nativeStructuredClone) || structuredCloneFromMark;
+
+	var throwUncloneable = function (type) {
+	  throw new DOMException('Uncloneable type: ' + type, DATA_CLONE_ERROR);
+	};
+
+	var throwUnpolyfillable = function (type, action) {
+	  throw new DOMException((action || 'Cloning') + ' of ' + type + ' cannot be properly polyfilled in this engine', DATA_CLONE_ERROR);
+	};
+
+	var tryNativeRestrictedStructuredClone = function (value, type) {
+	  if (!nativeRestrictedStructuredClone) throwUnpolyfillable(type);
+	  return nativeRestrictedStructuredClone(value);
+	};
+
+	var createDataTransfer = function () {
+	  var dataTransfer;
+	  try {
+	    dataTransfer = new globalThis.DataTransfer();
+	  } catch (error) {
+	    try {
+	      dataTransfer = new globalThis.ClipboardEvent('').clipboardData;
+	    } catch (error2) { /* empty */ }
+	  }
+	  return dataTransfer && dataTransfer.items && dataTransfer.files ? dataTransfer : null;
+	};
+
+	var cloneBuffer = function (value, map, $type) {
+	  if (mapHas(map, value)) return mapGet(map, value);
+
+	  var type = $type || classof(value);
+	  var clone, length, options, source, target, i;
+
+	  if (type === 'SharedArrayBuffer') {
+	    if (nativeRestrictedStructuredClone) clone = nativeRestrictedStructuredClone(value);
+	    // SharedArrayBuffer should use shared memory, we can't polyfill it, so return the original
+	    else clone = value;
+	  } else {
+	    var DataView = globalThis.DataView;
+
+	    // `ArrayBuffer#slice` is not available in IE10
+	    // `ArrayBuffer#slice` and `DataView` are not available in old FF
+	    if (!DataView && !isCallable(value.slice)) throwUnpolyfillable('ArrayBuffer');
+	    // detached buffers throws in `DataView` and `.slice`
+	    try {
+	      if (isCallable(value.slice) && !value.resizable) {
+	        clone = value.slice(0);
+	      } else {
+	        length = value.byteLength;
+	        options = 'maxByteLength' in value ? { maxByteLength: value.maxByteLength } : undefined;
+	        // eslint-disable-next-line es/no-resizable-and-growable-arraybuffers -- safe
+	        clone = new ArrayBuffer(length, options);
+	        source = new DataView(value);
+	        target = new DataView(clone);
+	        for (i = 0; i < length; i++) {
+	          target.setUint8(i, source.getUint8(i));
+	        }
+	      }
+	    } catch (error) {
+	      throw new DOMException('ArrayBuffer is detached', DATA_CLONE_ERROR);
+	    }
+	  }
+
+	  mapSet(map, value, clone);
+
+	  return clone;
+	};
+
+	var cloneView = function (value, type, offset, length, map) {
+	  var C = globalThis[type];
+	  // in some old engines like Safari 9, typeof C is 'object'
+	  // on Uint8ClampedArray or some other constructors
+	  if (!isObject(C)) throwUnpolyfillable(type);
+	  return new C(cloneBuffer(value.buffer, map), offset, length);
+	};
+
+	var structuredCloneInternal = function (value, map) {
+	  if (isSymbol(value)) throwUncloneable('Symbol');
+	  if (!isObject(value)) return value;
+	  // effectively preserves circular references
+	  if (map) {
+	    if (mapHas(map, value)) return mapGet(map, value);
+	  } else map = new Map();
+
+	  var type = classof(value);
+	  var C, name, cloned, dataTransfer, i, length, keys, key;
+
+	  switch (type) {
+	    case 'Array':
+	      cloned = Array(lengthOfArrayLike(value));
+	      break;
+	    case 'Object':
+	      cloned = {};
+	      break;
+	    case 'Map':
+	      cloned = new Map();
+	      break;
+	    case 'Set':
+	      cloned = new Set();
+	      break;
+	    case 'RegExp':
+	      // in this block because of a Safari 14.1 bug
+	      // old FF does not clone regexes passed to the constructor, so get the source and flags directly
+	      cloned = new RegExp(value.source, getRegExpFlags(value));
+	      break;
+	    case 'Error':
+	      name = value.name;
+	      switch (name) {
+	        case 'AggregateError':
+	          cloned = new (getBuiltIn(name))([]);
+	          break;
+	        case 'EvalError':
+	        case 'RangeError':
+	        case 'ReferenceError':
+	        case 'SuppressedError':
+	        case 'SyntaxError':
+	        case 'TypeError':
+	        case 'URIError':
+	          cloned = new (getBuiltIn(name))();
+	          break;
+	        case 'CompileError':
+	        case 'LinkError':
+	        case 'RuntimeError':
+	          cloned = new (getBuiltIn('WebAssembly', name))();
+	          break;
+	        default:
+	          cloned = new Error();
+	      }
+	      break;
+	    case 'DOMException':
+	      cloned = new DOMException(value.message, value.name);
+	      break;
+	    case 'ArrayBuffer':
+	    case 'SharedArrayBuffer':
+	      cloned = cloneBuffer(value, map, type);
+	      break;
+	    case 'DataView':
+	    case 'Int8Array':
+	    case 'Uint8Array':
+	    case 'Uint8ClampedArray':
+	    case 'Int16Array':
+	    case 'Uint16Array':
+	    case 'Int32Array':
+	    case 'Uint32Array':
+	    case 'Float16Array':
+	    case 'Float32Array':
+	    case 'Float64Array':
+	    case 'BigInt64Array':
+	    case 'BigUint64Array':
+	      length = type === 'DataView' ? value.byteLength : value.length;
+	      cloned = cloneView(value, type, value.byteOffset, length, map);
+	      break;
+	    case 'DOMQuad':
+	      try {
+	        cloned = new DOMQuad(
+	          structuredCloneInternal(value.p1, map),
+	          structuredCloneInternal(value.p2, map),
+	          structuredCloneInternal(value.p3, map),
+	          structuredCloneInternal(value.p4, map)
+	        );
+	      } catch (error) {
+	        cloned = tryNativeRestrictedStructuredClone(value, type);
+	      }
+	      break;
+	    case 'File':
+	      if (nativeRestrictedStructuredClone) try {
+	        cloned = nativeRestrictedStructuredClone(value);
+	        // NodeJS 20.0.0 bug, https://github.com/nodejs/node/issues/47612
+	        if (classof(cloned) !== type) cloned = undefined;
+	      } catch (error) { /* empty */ }
+	      if (!cloned) try {
+	        cloned = new File([value], value.name, value);
+	      } catch (error) { /* empty */ }
+	      if (!cloned) throwUnpolyfillable(type);
+	      break;
+	    case 'FileList':
+	      dataTransfer = createDataTransfer();
+	      if (dataTransfer) {
+	        for (i = 0, length = lengthOfArrayLike(value); i < length; i++) {
+	          dataTransfer.items.add(structuredCloneInternal(value[i], map));
+	        }
+	        cloned = dataTransfer.files;
+	      } else cloned = tryNativeRestrictedStructuredClone(value, type);
+	      break;
+	    case 'ImageData':
+	      // Safari 9 ImageData is a constructor, but typeof ImageData is 'object'
+	      try {
+	        cloned = new ImageData(
+	          structuredCloneInternal(value.data, map),
+	          value.width,
+	          value.height,
+	          { colorSpace: value.colorSpace }
+	        );
+	      } catch (error) {
+	        cloned = tryNativeRestrictedStructuredClone(value, type);
+	      } break;
+	    default:
+	      if (nativeRestrictedStructuredClone) {
+	        cloned = nativeRestrictedStructuredClone(value);
+	      } else switch (type) {
+	        case 'BigInt':
+	          // can be a 3rd party polyfill
+	          cloned = Object(value.valueOf());
+	          break;
+	        case 'Boolean':
+	          cloned = Object(thisBooleanValue(value));
+	          break;
+	        case 'Number':
+	          cloned = Object(thisNumberValue(value));
+	          break;
+	        case 'String':
+	          cloned = Object(thisStringValue(value));
+	          break;
+	        case 'Date':
+	          cloned = new Date(thisTimeValue(value));
+	          break;
+	        case 'Blob':
+	          try {
+	            cloned = value.slice(0, value.size, value.type);
+	          } catch (error) {
+	            throwUnpolyfillable(type);
+	          } break;
+	        case 'DOMPoint':
+	        case 'DOMPointReadOnly':
+	          C = globalThis[type];
+	          try {
+	            cloned = C.fromPoint
+	              ? C.fromPoint(value)
+	              : new C(value.x, value.y, value.z, value.w);
+	          } catch (error) {
+	            throwUnpolyfillable(type);
+	          } break;
+	        case 'DOMRect':
+	        case 'DOMRectReadOnly':
+	          C = globalThis[type];
+	          try {
+	            cloned = C.fromRect
+	              ? C.fromRect(value)
+	              : new C(value.x, value.y, value.width, value.height);
+	          } catch (error) {
+	            throwUnpolyfillable(type);
+	          } break;
+	        case 'DOMMatrix':
+	        case 'DOMMatrixReadOnly':
+	          C = globalThis[type];
+	          try {
+	            cloned = C.fromMatrix
+	              ? C.fromMatrix(value)
+	              : new C(value);
+	          } catch (error) {
+	            throwUnpolyfillable(type);
+	          } break;
+	        case 'AudioData':
+	        case 'VideoFrame':
+	          if (!isCallable(value.clone)) throwUnpolyfillable(type);
+	          try {
+	            cloned = value.clone();
+	          } catch (error) {
+	            throwUncloneable(type);
+	          } break;
+	        case 'CropTarget':
+	        case 'CryptoKey':
+	        case 'FileSystemDirectoryHandle':
+	        case 'FileSystemFileHandle':
+	        case 'FileSystemHandle':
+	        case 'GPUCompilationInfo':
+	        case 'GPUCompilationMessage':
+	        case 'ImageBitmap':
+	        case 'RTCCertificate':
+	        case 'WebAssembly.Module':
+	          throwUnpolyfillable(type);
+	          // break omitted
+	        default:
+	          throwUncloneable(type);
+	      }
+	  }
+
+	  mapSet(map, value, cloned);
+
+	  switch (type) {
+	    case 'Array':
+	    case 'Object':
+	      keys = objectKeys(value);
+	      for (i = 0, length = lengthOfArrayLike(keys); i < length; i++) {
+	        key = keys[i];
+	        createProperty(cloned, key, structuredCloneInternal(value[key], map));
+	      } break;
+	    case 'Map':
+	      value.forEach(function (v, k) {
+	        mapSet(cloned, structuredCloneInternal(k, map), structuredCloneInternal(v, map));
+	      });
+	      break;
+	    case 'Set':
+	      value.forEach(function (v) {
+	        setAdd(cloned, structuredCloneInternal(v, map));
+	      });
+	      break;
+	    case 'Error':
+	      createNonEnumerableProperty(cloned, 'message', structuredCloneInternal(value.message, map));
+	      if (hasOwn(value, 'cause')) {
+	        createNonEnumerableProperty(cloned, 'cause', structuredCloneInternal(value.cause, map));
+	      }
+	      if (name === 'AggregateError') {
+	        cloned.errors = structuredCloneInternal(value.errors, map);
+	      } else if (name === 'SuppressedError') {
+	        cloned.error = structuredCloneInternal(value.error, map);
+	        cloned.suppressed = structuredCloneInternal(value.suppressed, map);
+	      } // break omitted
+	    case 'DOMException':
+	      if (ERROR_STACK_INSTALLABLE) {
+	        createNonEnumerableProperty(cloned, 'stack', structuredCloneInternal(value.stack, map));
+	      }
+	  }
+
+	  return cloned;
+	};
+
+	var tryToTransfer = function (rawTransfer, map) {
+	  if (!isObject(rawTransfer)) throw new TypeError('Transfer option cannot be converted to a sequence');
+
+	  var transfer = [];
+
+	  iterate(rawTransfer, function (value) {
+	    push(transfer, anObject(value));
+	  });
+
+	  var i = 0;
+	  var length = lengthOfArrayLike(transfer);
+	  var buffers = new Set();
+	  var value, type, C, transferred, canvas, context;
+
+	  while (i < length) {
+	    value = transfer[i++];
+
+	    type = classof(value);
+
+	    if (type === 'ArrayBuffer' ? setHas(buffers, value) : mapHas(map, value)) {
+	      throw new DOMException('Duplicate transferable', DATA_CLONE_ERROR);
+	    }
+
+	    if (type === 'ArrayBuffer') {
+	      setAdd(buffers, value);
+	      continue;
+	    }
+
+	    if (PROPER_STRUCTURED_CLONE_TRANSFER) {
+	      transferred = nativeStructuredClone(value, { transfer: [value] });
+	    } else switch (type) {
+	      case 'ImageBitmap':
+	        C = globalThis.OffscreenCanvas;
+	        if (!isConstructor(C)) throwUnpolyfillable(type, TRANSFERRING);
+	        try {
+	          canvas = new C(value.width, value.height);
+	          context = canvas.getContext('bitmaprenderer');
+	          context.transferFromImageBitmap(value);
+	          transferred = canvas.transferToImageBitmap();
+	        } catch (error) { /* empty */ }
+	        break;
+	      case 'AudioData':
+	      case 'VideoFrame':
+	        if (!isCallable(value.clone) || !isCallable(value.close)) throwUnpolyfillable(type, TRANSFERRING);
+	        try {
+	          transferred = value.clone();
+	          value.close();
+	        } catch (error) { /* empty */ }
+	        break;
+	      case 'MediaSourceHandle':
+	      case 'MessagePort':
+	      case 'MIDIAccess':
+	      case 'OffscreenCanvas':
+	      case 'ReadableStream':
+	      case 'RTCDataChannel':
+	      case 'TransformStream':
+	      case 'WebTransportReceiveStream':
+	      case 'WebTransportSendStream':
+	      case 'WritableStream':
+	        throwUnpolyfillable(type, TRANSFERRING);
+	    }
+
+	    if (transferred === undefined) throw new DOMException('This object cannot be transferred: ' + type, DATA_CLONE_ERROR);
+
+	    mapSet(map, value, transferred);
+	  }
+
+	  return buffers;
+	};
+
+	var detachBuffers = function (buffers) {
+	  setIterate(buffers, function (buffer) {
+	    if (PROPER_STRUCTURED_CLONE_TRANSFER) {
+	      nativeRestrictedStructuredClone(buffer, { transfer: [buffer] });
+	    } else if (isCallable(buffer.transfer)) {
+	      buffer.transfer();
+	    } else if (detachTransferable) {
+	      detachTransferable(buffer);
+	    } else {
+	      throwUnpolyfillable('ArrayBuffer', TRANSFERRING);
+	    }
+	  });
+	};
+
+	// `structuredClone` method
+	// https://html.spec.whatwg.org/multipage/structured-data.html#dom-structuredclone
+	$({ global: true, enumerable: true, sham: !PROPER_STRUCTURED_CLONE_TRANSFER, forced: FORCED_REPLACEMENT }, {
+	  structuredClone: function structuredClone(value /* , { transfer } */) {
+	    var options = validateArgumentsLength(arguments.length, 1) > 1 && !isNullOrUndefined(arguments[1]) ? anObject(arguments[1]) : undefined;
+	    var transfer = options ? options.transfer : undefined;
+	    var map, buffers;
+
+	    if (transfer !== undefined) {
+	      map = new Map();
+	      buffers = tryToTransfer(transfer, map);
+	    }
+
+	    var clone = structuredCloneInternal(value, map);
+
+	    // since of an issue with cloning views of transferred buffers, we a forced to detach them later
+	    // https://github.com/zloirock/core-js/issues/1265
+	    if (buffers) detachBuffers(buffers);
+
+	    return clone;
+	  }
+	});
+	return web_structuredClone;
+}
+
+requireWeb_structuredClone();

package/dist/assets/{pushConnection.store-CTrZ_kO6.js → pushConnection.store-C6PSl50Z.js}

@@ -1,4 +1,4 @@
-import { C as createEventBus, R as defineStore, S as STORES, Z as useRootStore, p as useSettingsStore, q as computed, r as ref, W as TIME } from "./index-CWcTt6jd.js";
+import { C as createEventBus, R as defineStore, S as STORES, Z as useRootStore, p as useSettingsStore, q as computed, r as ref, W as TIME } from "./index-BW7gX0J2.js";
 const globalLinkActionsEventBus = createEventBus();
 const usePushConnectionStore = defineStore(STORES.PUSH, () => {
   const rootStore = useRootStore();

package/dist/assets/{templateActions-B712CNo3.js → templateActions-BHlzMnfj.js}

@@ -1,4 +1,4 @@
-import { fD as TEMPLATE_CREDENTIAL_SETUP_EXPERIMENT, dq as assert, V as VIEWS, dT as tryToParseNumber, fH as doesNodeHaveCredentialsToFill, fI as getNewWorkflow, fJ as replaceAllTemplateNodeCredentials, dS as getFixedNodesList } from "./index-CWcTt6jd.js";
+import { fB as TEMPLATE_CREDENTIAL_SETUP_EXPERIMENT, dn as assert, V as VIEWS, dR as tryToParseNumber, fF as doesNodeHaveCredentialsToFill, fG as getNewWorkflow, fH as replaceAllTemplateNodeCredentials, dQ as getFixedNodesList } from "./index-BW7gX0J2.js";
 async function createWorkflowFromTemplate(opts) {
   const { credentialOverrides, nodeTypeProvider, rootStore, template, workflowsStore } = opts;
   const workflowData = await getNewWorkflow(rootStore.restApiContext, { name: template.name });