n8n-editor-ui 1.100.0 → 1.101.0

package/dist/assets/{index-Cjj5DRsU.js → index-uJOu4Uio.js}

@@ -1,4 +1,4 @@
-import { gE as Chart$1, d as defineComponent, gF as shallowRef, ay as h, gG as LineController, gH as version, r as ref, o as onMounted, z as onBeforeUnmount, $ as watch, bl as toRaw, bk as isProxy, gI as BarController } from "./index-ZImlcrmd.js";
+import { h3 as Chart$1, d as defineComponent, dK as shallowRef, aJ as h, h4 as LineController, h5 as version, r as ref, o as onMounted, I as onBeforeUnmount, a9 as watch, bC as toRaw, bB as isProxy, h6 as BarController } from "./index-7S5ADieN.js";
 const CommonProps = {
   data: {
     type: Object,

package/dist/assets/{pickBy-C61vriIY.js → pickBy-DPxZbMic.js}

@@ -1,4 +1,4 @@
-import { gv as require_arrayMap, gw as require_baseIteratee, gx as require_basePickBy, gy as require_getAllKeysIn, bz as getDefaultExportFromCjs } from "./index-ZImlcrmd.js";
+import { gV as require_arrayMap, gW as require_baseIteratee, gX as require_basePickBy, gY as require_getAllKeysIn, bQ as getDefaultExportFromCjs } from "./index-7S5ADieN.js";
 var pickBy_1;
 var hasRequiredPickBy;
 function requirePickBy() {

package/dist/assets/{polyfills-deFGRMT9.js → polyfills-B8p9DdqU.js}

@@ -3887,7 +3887,33 @@ function requireEs_set_union_v2 () {
 
 requireEs_set_union_v2();
 
-var esnext_suppressedError_constructor = {};
+var es_typedArray_with = {};
+
+var arrayWith;
+var hasRequiredArrayWith;
+
+function requireArrayWith () {
+	if (hasRequiredArrayWith) return arrayWith;
+	hasRequiredArrayWith = 1;
+	var lengthOfArrayLike = requireLengthOfArrayLike();
+	var toIntegerOrInfinity = requireToIntegerOrInfinity();
+
+	var $RangeError = RangeError;
+
+	// https://tc39.es/proposal-change-array-by-copy/#sec-array.prototype.with
+	// https://tc39.es/proposal-change-array-by-copy/#sec-%typedarray%.prototype.with
+	arrayWith = function (O, C, index, value) {
+	  var len = lengthOfArrayLike(O);
+	  var relativeIndex = toIntegerOrInfinity(index);
+	  var actualIndex = relativeIndex < 0 ? len + relativeIndex : relativeIndex;
+	  if (actualIndex >= len || actualIndex < 0) throw new $RangeError('Incorrect index');
+	  var A = new C(len);
+	  var k = 0;
+	  for (; k < len; k++) A[k] = k === actualIndex ? value : O[k];
+	  return A;
+	};
+	return arrayWith;
+}
 
 var isPossiblePrototype;
 var hasRequiredIsPossiblePrototype;
@@ -3958,6 +3984,284 @@ function requireObjectSetPrototypeOf () {
 	return objectSetPrototypeOf;
 }
 
+var arrayBufferViewCore;
+var hasRequiredArrayBufferViewCore;
+
+function requireArrayBufferViewCore () {
+	if (hasRequiredArrayBufferViewCore) return arrayBufferViewCore;
+	hasRequiredArrayBufferViewCore = 1;
+	var NATIVE_ARRAY_BUFFER = requireArrayBufferBasicDetection();
+	var DESCRIPTORS = requireDescriptors();
+	var globalThis = requireGlobalThis();
+	var isCallable = requireIsCallable();
+	var isObject = requireIsObject();
+	var hasOwn = requireHasOwnProperty();
+	var classof = requireClassof();
+	var tryToString = requireTryToString();
+	var createNonEnumerableProperty = requireCreateNonEnumerableProperty();
+	var defineBuiltIn = requireDefineBuiltIn();
+	var defineBuiltInAccessor = requireDefineBuiltInAccessor();
+	var isPrototypeOf = requireObjectIsPrototypeOf();
+	var getPrototypeOf = requireObjectGetPrototypeOf();
+	var setPrototypeOf = requireObjectSetPrototypeOf();
+	var wellKnownSymbol = requireWellKnownSymbol();
+	var uid = requireUid();
+	var InternalStateModule = requireInternalState();
+
+	var enforceInternalState = InternalStateModule.enforce;
+	var getInternalState = InternalStateModule.get;
+	var Int8Array = globalThis.Int8Array;
+	var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
+	var Uint8ClampedArray = globalThis.Uint8ClampedArray;
+	var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
+	var TypedArray = Int8Array && getPrototypeOf(Int8Array);
+	var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
+	var ObjectPrototype = Object.prototype;
+	var TypeError = globalThis.TypeError;
+
+	var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+	var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
+	var TYPED_ARRAY_CONSTRUCTOR = 'TypedArrayConstructor';
+	// Fixing native typed arrays in Opera Presto crashes the browser, see #595
+	var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(globalThis.opera) !== 'Opera';
+	var TYPED_ARRAY_TAG_REQUIRED = false;
+	var NAME, Constructor, Prototype;
+
+	var TypedArrayConstructorsList = {
+	  Int8Array: 1,
+	  Uint8Array: 1,
+	  Uint8ClampedArray: 1,
+	  Int16Array: 2,
+	  Uint16Array: 2,
+	  Int32Array: 4,
+	  Uint32Array: 4,
+	  Float32Array: 4,
+	  Float64Array: 8
+	};
+
+	var BigIntArrayConstructorsList = {
+	  BigInt64Array: 8,
+	  BigUint64Array: 8
+	};
+
+	var isView = function isView(it) {
+	  if (!isObject(it)) return false;
+	  var klass = classof(it);
+	  return klass === 'DataView'
+	    || hasOwn(TypedArrayConstructorsList, klass)
+	    || hasOwn(BigIntArrayConstructorsList, klass);
+	};
+
+	var getTypedArrayConstructor = function (it) {
+	  var proto = getPrototypeOf(it);
+	  if (!isObject(proto)) return;
+	  var state = getInternalState(proto);
+	  return (state && hasOwn(state, TYPED_ARRAY_CONSTRUCTOR)) ? state[TYPED_ARRAY_CONSTRUCTOR] : getTypedArrayConstructor(proto);
+	};
+
+	var isTypedArray = function (it) {
+	  if (!isObject(it)) return false;
+	  var klass = classof(it);
+	  return hasOwn(TypedArrayConstructorsList, klass)
+	    || hasOwn(BigIntArrayConstructorsList, klass);
+	};
+
+	var aTypedArray = function (it) {
+	  if (isTypedArray(it)) return it;
+	  throw new TypeError('Target is not a typed array');
+	};
+
+	var aTypedArrayConstructor = function (C) {
+	  if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;
+	  throw new TypeError(tryToString(C) + ' is not a typed array constructor');
+	};
+
+	var exportTypedArrayMethod = function (KEY, property, forced, options) {
+	  if (!DESCRIPTORS) return;
+	  if (forced) for (var ARRAY in TypedArrayConstructorsList) {
+	    var TypedArrayConstructor = globalThis[ARRAY];
+	    if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {
+	      delete TypedArrayConstructor.prototype[KEY];
+	    } catch (error) {
+	      // old WebKit bug - some methods are non-configurable
+	      try {
+	        TypedArrayConstructor.prototype[KEY] = property;
+	      } catch (error2) { /* empty */ }
+	    }
+	  }
+	  if (!TypedArrayPrototype[KEY] || forced) {
+	    defineBuiltIn(TypedArrayPrototype, KEY, forced ? property
+	      : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);
+	  }
+	};
+
+	var exportTypedArrayStaticMethod = function (KEY, property, forced) {
+	  var ARRAY, TypedArrayConstructor;
+	  if (!DESCRIPTORS) return;
+	  if (setPrototypeOf) {
+	    if (forced) for (ARRAY in TypedArrayConstructorsList) {
+	      TypedArrayConstructor = globalThis[ARRAY];
+	      if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {
+	        delete TypedArrayConstructor[KEY];
+	      } catch (error) { /* empty */ }
+	    }
+	    if (!TypedArray[KEY] || forced) {
+	      // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable
+	      try {
+	        return defineBuiltIn(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
+	      } catch (error) { /* empty */ }
+	    } else return;
+	  }
+	  for (ARRAY in TypedArrayConstructorsList) {
+	    TypedArrayConstructor = globalThis[ARRAY];
+	    if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
+	      defineBuiltIn(TypedArrayConstructor, KEY, property);
+	    }
+	  }
+	};
+
+	for (NAME in TypedArrayConstructorsList) {
+	  Constructor = globalThis[NAME];
+	  Prototype = Constructor && Constructor.prototype;
+	  if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
+	  else NATIVE_ARRAY_BUFFER_VIEWS = false;
+	}
+
+	for (NAME in BigIntArrayConstructorsList) {
+	  Constructor = globalThis[NAME];
+	  Prototype = Constructor && Constructor.prototype;
+	  if (Prototype) enforceInternalState(Prototype)[TYPED_ARRAY_CONSTRUCTOR] = Constructor;
+	}
+
+	// WebKit bug - typed arrays constructors prototype is Object.prototype
+	if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {
+	  // eslint-disable-next-line no-shadow -- safe
+	  TypedArray = function TypedArray() {
+	    throw new TypeError('Incorrect invocation');
+	  };
+	  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
+	    if (globalThis[NAME]) setPrototypeOf(globalThis[NAME], TypedArray);
+	  }
+	}
+
+	if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
+	  TypedArrayPrototype = TypedArray.prototype;
+	  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
+	    if (globalThis[NAME]) setPrototypeOf(globalThis[NAME].prototype, TypedArrayPrototype);
+	  }
+	}
+
+	// WebKit bug - one more object in Uint8ClampedArray prototype chain
+	if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
+	  setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
+	}
+
+	if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {
+	  TYPED_ARRAY_TAG_REQUIRED = true;
+	  defineBuiltInAccessor(TypedArrayPrototype, TO_STRING_TAG, {
+	    configurable: true,
+	    get: function () {
+	      return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
+	    }
+	  });
+	  for (NAME in TypedArrayConstructorsList) if (globalThis[NAME]) {
+	    createNonEnumerableProperty(globalThis[NAME], TYPED_ARRAY_TAG, NAME);
+	  }
+	}
+
+	arrayBufferViewCore = {
+	  NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
+	  TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,
+	  aTypedArray: aTypedArray,
+	  aTypedArrayConstructor: aTypedArrayConstructor,
+	  exportTypedArrayMethod: exportTypedArrayMethod,
+	  exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
+	  getTypedArrayConstructor: getTypedArrayConstructor,
+	  isView: isView,
+	  isTypedArray: isTypedArray,
+	  TypedArray: TypedArray,
+	  TypedArrayPrototype: TypedArrayPrototype
+	};
+	return arrayBufferViewCore;
+}
+
+var isBigIntArray;
+var hasRequiredIsBigIntArray;
+
+function requireIsBigIntArray () {
+	if (hasRequiredIsBigIntArray) return isBigIntArray;
+	hasRequiredIsBigIntArray = 1;
+	var classof = requireClassof();
+
+	isBigIntArray = function (it) {
+	  var klass = classof(it);
+	  return klass === 'BigInt64Array' || klass === 'BigUint64Array';
+	};
+	return isBigIntArray;
+}
+
+var toBigInt;
+var hasRequiredToBigInt;
+
+function requireToBigInt () {
+	if (hasRequiredToBigInt) return toBigInt;
+	hasRequiredToBigInt = 1;
+	var toPrimitive = requireToPrimitive();
+
+	var $TypeError = TypeError;
+
+	// `ToBigInt` abstract operation
+	// https://tc39.es/ecma262/#sec-tobigint
+	toBigInt = function (argument) {
+	  var prim = toPrimitive(argument, 'number');
+	  if (typeof prim == 'number') throw new $TypeError("Can't convert number to bigint");
+	  // eslint-disable-next-line es/no-bigint -- safe
+	  return BigInt(prim);
+	};
+	return toBigInt;
+}
+
+var hasRequiredEs_typedArray_with;
+
+function requireEs_typedArray_with () {
+	if (hasRequiredEs_typedArray_with) return es_typedArray_with;
+	hasRequiredEs_typedArray_with = 1;
+	var arrayWith = requireArrayWith();
+	var ArrayBufferViewCore = requireArrayBufferViewCore();
+	var isBigIntArray = requireIsBigIntArray();
+	var toIntegerOrInfinity = requireToIntegerOrInfinity();
+	var toBigInt = requireToBigInt();
+
+	var aTypedArray = ArrayBufferViewCore.aTypedArray;
+	var getTypedArrayConstructor = ArrayBufferViewCore.getTypedArrayConstructor;
+	var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
+
+	var PROPER_ORDER = !!function () {
+	  try {
+	    // eslint-disable-next-line no-throw-literal, es/no-typed-arrays, es/no-array-prototype-with -- required for testing
+	    new Int8Array(1)['with'](2, { valueOf: function () { throw 8; } });
+	  } catch (error) {
+	    // some early implementations, like WebKit, does not follow the final semantic
+	    // https://github.com/tc39/proposal-change-array-by-copy/pull/86
+	    return error === 8;
+	  }
+	}();
+
+	// `%TypedArray%.prototype.with` method
+	// https://tc39.es/ecma262/#sec-%typedarray%.prototype.with
+	exportTypedArrayMethod('with', { 'with': function (index, value) {
+	  var O = aTypedArray(this);
+	  var relativeIndex = toIntegerOrInfinity(index);
+	  var actualValue = isBigIntArray(O) ? toBigInt(value) : +value;
+	  return arrayWith(O, getTypedArrayConstructor(O), relativeIndex, actualValue);
+	} }['with'], !PROPER_ORDER);
+	return es_typedArray_with;
+}
+
+requireEs_typedArray_with();
+
+var esnext_suppressedError_constructor = {};
+
 var errorStackClear;
 var hasRequiredErrorStackClear;
 
@@ -4245,6 +4549,89 @@ function requireEsnext_array_group () {
 
 requireEsnext_array_group();
 
+var esnext_asyncIterator_asyncDispose = {};
+
+var asyncIteratorPrototype;
+var hasRequiredAsyncIteratorPrototype;
+
+function requireAsyncIteratorPrototype () {
+	if (hasRequiredAsyncIteratorPrototype) return asyncIteratorPrototype;
+	hasRequiredAsyncIteratorPrototype = 1;
+	var globalThis = requireGlobalThis();
+	var shared = requireSharedStore();
+	var isCallable = requireIsCallable();
+	var create = requireObjectCreate();
+	var getPrototypeOf = requireObjectGetPrototypeOf();
+	var defineBuiltIn = requireDefineBuiltIn();
+	var wellKnownSymbol = requireWellKnownSymbol();
+	var IS_PURE = requireIsPure();
+
+	var USE_FUNCTION_CONSTRUCTOR = 'USE_FUNCTION_CONSTRUCTOR';
+	var ASYNC_ITERATOR = wellKnownSymbol('asyncIterator');
+	var AsyncIterator = globalThis.AsyncIterator;
+	var PassedAsyncIteratorPrototype = shared.AsyncIteratorPrototype;
+	var AsyncIteratorPrototype, prototype;
+
+	if (PassedAsyncIteratorPrototype) {
+	  AsyncIteratorPrototype = PassedAsyncIteratorPrototype;
+	} else if (isCallable(AsyncIterator)) {
+	  AsyncIteratorPrototype = AsyncIterator.prototype;
+	} else if (shared[USE_FUNCTION_CONSTRUCTOR] || globalThis[USE_FUNCTION_CONSTRUCTOR]) {
+	  try {
+	    // eslint-disable-next-line no-new-func -- we have no alternatives without usage of modern syntax
+	    prototype = getPrototypeOf(getPrototypeOf(getPrototypeOf(Function('return async function*(){}()')())));
+	    if (getPrototypeOf(prototype) === Object.prototype) AsyncIteratorPrototype = prototype;
+	  } catch (error) { /* empty */ }
+	}
+
+	if (!AsyncIteratorPrototype) AsyncIteratorPrototype = {};
+	else if (IS_PURE) AsyncIteratorPrototype = create(AsyncIteratorPrototype);
+
+	if (!isCallable(AsyncIteratorPrototype[ASYNC_ITERATOR])) {
+	  defineBuiltIn(AsyncIteratorPrototype, ASYNC_ITERATOR, function () {
+	    return this;
+	  });
+	}
+
+	asyncIteratorPrototype = AsyncIteratorPrototype;
+	return asyncIteratorPrototype;
+}
+
+var hasRequiredEsnext_asyncIterator_asyncDispose;
+
+function requireEsnext_asyncIterator_asyncDispose () {
+	if (hasRequiredEsnext_asyncIterator_asyncDispose) return esnext_asyncIterator_asyncDispose;
+	hasRequiredEsnext_asyncIterator_asyncDispose = 1;
+	// https://github.com/tc39/proposal-async-explicit-resource-management
+	var call = requireFunctionCall();
+	var defineBuiltIn = requireDefineBuiltIn();
+	var getBuiltIn = requireGetBuiltIn();
+	var getMethod = requireGetMethod();
+	var hasOwn = requireHasOwnProperty();
+	var wellKnownSymbol = requireWellKnownSymbol();
+	var AsyncIteratorPrototype = requireAsyncIteratorPrototype();
+
+	var ASYNC_DISPOSE = wellKnownSymbol('asyncDispose');
+	var Promise = getBuiltIn('Promise');
+
+	if (!hasOwn(AsyncIteratorPrototype, ASYNC_DISPOSE)) {
+	  defineBuiltIn(AsyncIteratorPrototype, ASYNC_DISPOSE, function () {
+	    var O = this;
+	    return new Promise(function (resolve, reject) {
+	      var $return = getMethod(O, 'return');
+	      if ($return) {
+	        Promise.resolve(call($return, O)).then(function () {
+	          resolve(undefined);
+	        }, reject);
+	      } else resolve(undefined);
+	    });
+	  });
+	}
+	return esnext_asyncIterator_asyncDispose;
+}
+
+requireEsnext_asyncIterator_asyncDispose();
+
 var esnext_iterator_dispose = {};
 
 var hasRequiredEsnext_iterator_dispose;

package/dist/assets/{templateActions-DgE3PfYi.js → templateActions-DJJfyIhq.js}

@@ -1,4 +1,4 @@
-import { e_ as assert, fc as doesNodeHaveCredentialsToFill, V as VIEWS, ek as tryToParseNumber, fd as getNewWorkflow, fe as replaceAllTemplateNodeCredentials, el as getNodesWithNormalizedPosition } from "./index-ZImlcrmd.js";
+import { fu as assert, fJ as doesNodeHaveCredentialsToFill, V as VIEWS, eI as tryToParseNumber, fK as getNewWorkflow, fL as replaceAllTemplateNodeCredentials, eJ as getNodesWithNormalizedPosition } from "./index-7S5ADieN.js";
 async function createWorkflowFromTemplate(opts) {
   const { credentialOverrides, nodeTypeProvider, rootStore, template, workflowsStore } = opts;
   const workflowData = await getNewWorkflow(rootStore.restApiContext, { name: template.name });

package/dist/assets/{typescript.worker-DIrCbxuR.js → typescript.worker-CUj0Nj-S.js}

@@ -6417,7 +6417,7 @@ function requireTypescript() {
       });
       module2.exports = __toCommonJS(typescript_exports);
       var versionMajorMinor = "5.8";
-      var version = "5.8.2";
+      var version = "5.8.3";
       var Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -63033,10 +63033,11 @@ ${lanes.join("\n")}
             serializeExistingTypeNode(context, typeNode, addUndefined) {
               return serializeExistingTypeNode(context, typeNode, !!addUndefined);
             },
-            serializeReturnTypeForSignature(syntacticContext, signatureDeclaration) {
+            serializeReturnTypeForSignature(syntacticContext, signatureDeclaration, symbol) {
               const context = syntacticContext;
               const signature = getSignatureFromDeclaration(signatureDeclaration);
-              const returnType = context.enclosingSymbolTypes.get(getSymbolId(getSymbolOfDeclaration(signatureDeclaration))) ?? instantiateType(getReturnTypeOfSignature(signature), context.mapper);
+              symbol ?? (symbol = getSymbolOfDeclaration(signatureDeclaration));
+              const returnType = context.enclosingSymbolTypes.get(getSymbolId(symbol)) ?? instantiateType(getReturnTypeOfSignature(signature), context.mapper);
               return serializeInferredReturnTypeForSignature(context, signature, returnType);
             },
             serializeTypeOfExpression(syntacticContext, expr) {
@@ -63050,7 +63051,7 @@ ${lanes.join("\n")}
               symbol ?? (symbol = getSymbolOfDeclaration(declaration));
               let type = (_a = context.enclosingSymbolTypes) == null ? void 0 : _a.get(getSymbolId(symbol));
               if (type === void 0) {
-                type = symbol && !(symbol.flags & (2048 | 131072)) ? instantiateType(getWidenedLiteralType(getTypeOfSymbol(symbol)), context.mapper) : errorType;
+                type = symbol.flags & 98304 && declaration.kind === 178 ? instantiateType(getWriteTypeOfSymbol(symbol), context.mapper) : symbol && !(symbol.flags & (2048 | 131072)) ? instantiateType(getWidenedLiteralType(getTypeOfSymbol(symbol)), context.mapper) : errorType;
               }
               const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
               if (addUndefinedForParameter) {
@@ -63115,6 +63116,7 @@ ${lanes.join("\n")}
               const context = syntacticContext;
               if (context.bundled || context.enclosingFile !== getSourceFileOfNode(lit)) {
                 let name = lit.text;
+                const originalName = name;
                 const nodeSymbol = getNodeLinks(parent2).resolvedSymbol;
                 const meaning = parent2.isTypeOf ? 111551 : 788968;
                 const parentSymbol = nodeSymbol && isSymbolAccessible(
@@ -63144,7 +63146,9 @@ ${lanes.join("\n")}
                     context.tracker.reportLikelyUnsafeImportRequiredError(name);
                   }
                 }
-                return name;
+                if (name !== originalName) {
+                  return name;
+                }
               }
             },
             canReuseTypeNode(context, typeNode) {
@@ -64327,6 +64331,7 @@ ${lanes.join("\n")}
             if (propertySymbol.flags & 98304) {
               const writeType = getWriteTypeOfSymbol(propertySymbol);
               if (propertyType !== writeType && !isErrorType(propertyType) && !isErrorType(writeType)) {
+                const symbolMapper = getSymbolLinks(propertySymbol).mapper;
                 const getterDeclaration = getDeclarationOfKind(
                   propertySymbol,
                   177
@@ -64336,7 +64341,7 @@ ${lanes.join("\n")}
                 typeElements.push(
                   setCommentRange2(
                     context,
-                    signatureToSignatureDeclarationHelper(getterSignature, 177, context, { name: propertyName }),
+                    signatureToSignatureDeclarationHelper(symbolMapper ? instantiateSignature(getterSignature, symbolMapper) : getterSignature, 177, context, { name: propertyName }),
                     getterDeclaration
                   )
                 );
@@ -64349,7 +64354,7 @@ ${lanes.join("\n")}
                 typeElements.push(
                   setCommentRange2(
                     context,
-                    signatureToSignatureDeclarationHelper(setterSignature, 178, context, { name: propertyName }),
+                    signatureToSignatureDeclarationHelper(symbolMapper ? instantiateSignature(setterSignature, symbolMapper) : setterSignature, 178, context, { name: propertyName }),
                     setterDeclaration
                   )
                 );
@@ -65614,13 +65619,13 @@ ${lanes.join("\n")}
             const addUndefinedForParameter = declaration && (isParameter(declaration) || isJSDocParameterTag(declaration)) && requiresAddingImplicitUndefined(declaration, context.enclosingDeclaration);
             const decl = declaration ?? symbol.valueDeclaration ?? getDeclarationWithTypeAnnotation(symbol) ?? ((_a = symbol.declarations) == null ? void 0 : _a[0]);
             if (decl) {
+              const restore = addSymbolTypeToContext(context, symbol, type);
               if (isAccessor(decl)) {
                 result = syntacticNodeBuilder.serializeTypeOfAccessor(decl, symbol, context);
               } else if (hasInferredType(decl) && !nodeIsSynthesized(decl) && !(getObjectFlags(type) & 196608)) {
-                const restore = addSymbolTypeToContext(context, symbol, type);
                 result = syntacticNodeBuilder.serializeTypeOfDeclaration(decl, symbol, context);
-                restore();
               }
+              restore();
             }
             if (!result) {
               if (addUndefinedForParameter) {
@@ -65792,10 +65797,7 @@ ${lanes.join("\n")}
                 /*context*/
                 void 0
               );
-              if (updated !== node2) {
-                setTextRange2(context, updated, node2);
-              }
-              return updated;
+              return setTextRange2(context, updated, node2);
             }
           }
           function serializeTypeName(context, node, isTypeOf, typeArguments) {
@@ -91354,6 +91356,11 @@ ${lanes.join("\n")}
             ])) {
               grammarErrorOnNode(node, Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead);
             }
+            if (compilerOptions.erasableSyntaxOnly) {
+              const start = skipTrivia(file.text, node.pos);
+              const end = node.expression.pos;
+              diagnostics.add(createFileDiagnostic(file, start, end - start, Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled));
+            }
           }
           return checkAssertionWorker(node, checkMode);
         }
@@ -150199,9 +150206,11 @@ ${lanes.join("\n")}
               if (!resolver.canReuseTypeNode(context, node)) {
                 return resolver.serializeExistingTypeNode(context, node);
               }
+              const specifier = rewriteModuleSpecifier2(node, node.argument.literal);
+              const literal = specifier === node.argument.literal ? reuseNode(context, node.argument.literal) : specifier;
               return factory.updateImportTypeNode(
                 node,
-                factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier2(node, node.argument.literal)),
+                literal === node.argument.literal ? reuseNode(context, node.argument) : factory.createLiteralTypeNode(literal),
                 visitNode(node.attributes, visitExistingNodeTreeSymbols, isImportAttributes),
                 visitNode(node.qualifier, visitExistingNodeTreeSymbols, isEntityName),
                 visitNodes2(node.typeArguments, visitExistingNodeTreeSymbols, isTypeNode),
@@ -150362,10 +150371,7 @@ ${lanes.join("\n")}
             }
             function rewriteModuleSpecifier2(parent2, lit) {
               const newName = resolver.getModuleSpecifierOverride(context, parent2, lit);
-              if (newName) {
-                return setOriginalNode(factory.createStringLiteral(newName), lit);
-              }
-              return visitNode(lit, visitExistingNodeTreeSymbols, isStringLiteral);
+              return newName ? setOriginalNode(factory.createStringLiteral(newName), lit) : lit;
             }
           }
         }
@@ -150538,12 +150544,7 @@ ${lanes.join("\n")}
             return withNewScope(context, node, () => serializeTypeAnnotationOfDeclaration(accessorType, context, node, symbol) ?? inferTypeOfDeclaration(node, symbol, context));
           }
           if (accessorDeclarations.getAccessor) {
-            return withNewScope(context, accessorDeclarations.getAccessor, () => createReturnFromSignature(
-              accessorDeclarations.getAccessor,
-              /*symbol*/
-              void 0,
-              context
-            ));
+            return withNewScope(context, accessorDeclarations.getAccessor, () => createReturnFromSignature(accessorDeclarations.getAccessor, symbol, context));
           }
           return void 0;
         }
@@ -150662,7 +150663,7 @@ ${lanes.join("\n")}
             /* AnyKeyword */
           );
         }
-        function inferReturnTypeOfSignatureSignature(node, context, reportFallback) {
+        function inferReturnTypeOfSignatureSignature(node, context, symbol, reportFallback) {
           if (reportFallback) {
             context.tracker.reportInferenceFallback(node);
           }
@@ -150672,7 +150673,7 @@ ${lanes.join("\n")}
               /* AnyKeyword */
             );
           }
-          return resolver.serializeReturnTypeForSignature(context, node) ?? factory.createKeywordTypeNode(
+          return resolver.serializeReturnTypeForSignature(context, node, symbol) ?? factory.createKeywordTypeNode(
             133
             /* AnyKeyword */
           );
@@ -150987,18 +150988,17 @@ ${lanes.join("\n")}
           );
         }
         function reuseTypeParameters(typeParameters, context) {
-          return typeParameters == null ? void 0 : typeParameters.map(
-            (tp) => {
-              var _a;
-              return factory.updateTypeParameterDeclaration(
-                tp,
-                (_a = tp.modifiers) == null ? void 0 : _a.map((m) => reuseNode(context, m)),
-                reuseNode(context, tp.name),
-                serializeExistingTypeNodeWithFallback(tp.constraint, context),
-                serializeExistingTypeNodeWithFallback(tp.default, context)
-              );
-            }
-          );
+          return typeParameters == null ? void 0 : typeParameters.map((tp) => {
+            var _a;
+            const { node: tpName } = resolver.trackExistingEntityName(context, tp.name);
+            return factory.updateTypeParameterDeclaration(
+              tp,
+              (_a = tp.modifiers) == null ? void 0 : _a.map((m) => reuseNode(context, m)),
+              tpName,
+              serializeExistingTypeNodeWithFallback(tp.constraint, context),
+              serializeExistingTypeNodeWithFallback(tp.default, context)
+            );
+          });
         }
         function typeFromObjectLiteralMethod(method, name, context, isConstContext) {
           const returnType = createReturnFromSignature(
@@ -151151,7 +151151,7 @@ ${lanes.join("\n")}
           } else if (isValueSignatureDeclaration(fn)) {
             returnType = typeFromSingleReturnExpression(fn, context);
           }
-          return returnType.type !== void 0 ? returnType.type : inferReturnTypeOfSignatureSignature(fn, context, reportFallback && returnType.reportFallback && !returnTypeNode);
+          return returnType.type !== void 0 ? returnType.type : inferReturnTypeOfSignatureSignature(fn, context, symbol, reportFallback && returnType.reportFallback && !returnTypeNode);
         }
         function typeFromSingleReturnExpression(declaration, context) {
           let candidateExpr;

package/dist/assets/{useBeforeUnload-CX6OL9lX.js → useBeforeUnload-DveXGtGN.js}

@@ -1,4 +1,4 @@
-import { J as useUIStore, a2 as useCanvasStore, r as ref, x as computed, V as VIEWS, c as useI18n } from "./index-ZImlcrmd.js";
+import { S as useUIStore, ac as useCanvasStore, r as ref, x as computed, V as VIEWS, c as useI18n } from "./index-7S5ADieN.js";
 function useBeforeUnload({ route }) {
   const uiStore = useUIStore();
   const canvasStore = useCanvasStore();

package/dist/assets/{useExecutionDebugging-Bw29Xcz_.js → useExecutionDebugging-DM4nhx6D.js}

@@ -1,4 +1,4 @@
-import { b as useRouter, a as useToast, T as useWorkflowsStore, v as useSettingsStore, J as useUIStore, aa as usePageRedirectionHelper, x as computed, ae as EnterpriseEditionFeature, c as useI18n, ez as DEBUG_PAYWALL_MODAL_KEY, ay as h, dR as sanitizeHtml, ao as useMessage, ap as MODAL_CONFIRM, V as VIEWS, am as useTelemetry, a1 as useRootStore, eA as isFullExecutionResponse } from "./index-ZImlcrmd.js";
+import { b as useRouter, a as useToast, a3 as useWorkflowsStore, v as useSettingsStore, S as useUIStore, ak as usePageRedirectionHelper, x as computed, ao as EnterpriseEditionFeature, c as useI18n, eX as DEBUG_PAYWALL_MODAL_KEY, aJ as h, e9 as sanitizeHtml, az as useMessage, aA as MODAL_CONFIRM, V as VIEWS, ax as useTelemetry, ab as useRootStore, eY as isFullExecutionResponse } from "./index-7S5ADieN.js";
 const useExecutionDebugging = () => {
   const telemetry = useTelemetry();
   const router = useRouter();

package/dist/assets/{useExecutionHelpers-DfJOrkT9.js → useExecutionHelpers-BfF56crp.js}

@@ -1,4 +1,4 @@
-import { b as useRouter, V as VIEWS, am as useTelemetry, gm as convertToDisplayDate, c as useI18n } from "./index-ZImlcrmd.js";
+import { b as useRouter, V as VIEWS, ax as useTelemetry, gK as convertToDisplayDate, c as useI18n } from "./index-7S5ADieN.js";
 function useExecutionHelpers() {
   const i18n = useI18n();
   const router = useRouter();