n8n-nodes/n8n-nodes-gwezz-changdunovel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

first commit

Browse Source
This commit is contained in:
Sshelgwezz
2025-10-26 23:10:15 +08:00
commit 8f0345b7be
14961 changed files with 2356381 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
node_modules/n8n-workflow/dist/cjs/native-methods/array.methods.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import type { NativeDoc } from '../extensions/extensions';
export declare const arrayMethods: NativeDoc;
//# sourceMappingURL=array.methods.d.ts.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/array.methods.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"array.methods.d.ts","sourceRoot":"","sources":["../../../src/native-methods/array.methods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,eAAO,MAAM,YAAY,EAAE,SAukB1B,CAAC"}

552
node_modules/n8n-workflow/dist/cjs/native-methods/array.methods.js generated vendored Normal file
View File

@@ -0,0 +1,552 @@
(function (factory) {
if (typeof module === "object" && typeof module.exports === "object") {
var v = factory(require, exports);
if (v !== undefined) module.exports = v;
}
else if (typeof define === "function" && define.amd) {
define(["require", "exports"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.arrayMethods = void 0;
exports.arrayMethods = {
typeName: 'Array',
properties: {
length: {
doc: {
name: 'length',
description: 'The number of elements in the array',
examples: [{ example: "['Bob', 'Bill', 'Nat'].length", evaluated: '3' }],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length',
returnType: 'number',
},
},
},
functions: {
concat: {
doc: {
name: 'concat',
description: 'Joins one or more arrays onto the end of the base array',
examples: [
{
example: "['Nathan', 'Jan'].concat(['Steve', 'Bill'])",
evaluated: "['Nathan', 'Jan', 'Steve', 'Bill']",
},
{
example: "[5, 4].concat([100, 101], ['a', 'b'])",
evaluated: "[5, 4, 100, 101, 'a', 'b']",
},
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat',
returnType: 'Array',
args: [
{
name: 'arrays',
variadic: true,
description: 'The arrays to be joined on the end of the base array, in order',
type: 'Array',
},
],
},
},
filter: {
doc: {
name: 'filter',
description: 'Returns an array with only the elements satisfying a condition. The condition is a function that returns <code>true</code> or <code>false</code>.',
examples: [
{
example: '[12, 33, 16, 40].filter(age => age > 18)',
evaluated: '[33, 40]',
description: 'Keep ages over 18 (using arrow function notation)',
},
{
example: "['Nathan', 'Bob', 'Sebastian'].filter(name => name.length < 5)",
evaluated: "['Bob']",
description: 'Keep names under 5 letters long (using arrow function notation)',
},
{
example: "['Nathan', 'Bob', 'Sebastian'].filter(function(name) { return name.length < 5 })",
evaluated: "['Bob']",
description: 'Or using traditional function notation',
},
{
example: '[1, 7, 3, 10, 5].filter((num, index) => index % 2 !== 0)',
evaluated: '[7, 10]',
description: 'Keep numbers at odd indexes',
},
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter',
returnType: 'Array',
args: [
{
name: 'function',
description: 'A function to run for each array element. If it returns <code>true</code>, the element will be kept. Consider using <a target="_blank" href=”https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions”>arrow function notation</a> to save space.',
type: 'Function',
default: 'item => true',
args: [
{
name: 'element',
description: 'The value of the current element',
type: 'any',
},
{
name: 'index',
optional: true,
description: 'The position of the current element in the array (starting at 0)',
type: 'number',
},
{
name: 'array',
optional: true,
description: 'The array being processed. Rarely needed.',
type: 'Array',
},
{
name: 'thisValue',
optional: true,
description: 'A value passed to the function as its <code>this</code> value. Rarely needed.',
type: 'any',
},
],
},
],
},
},
find: {
doc: {
name: 'find',
description: 'Returns the first element from the array that satisfies the provided condition. The condition is a function that returns <code>true</code> or <code>false</code>. Returns <code>undefined</code> if no matches are found.\n\nIf you need all matching elements, use <code>filter()</code>.',
examples: [
{
example: '[12, 33, 16, 40].find(age => age > 18)',
evaluated: '33',
description: 'Find first age over 18 (using arrow function notation)',
},
{
example: "['Nathan', 'Bob', 'Sebastian'].find(name => name.length < 5)",
evaluated: "'Bob'",
description: 'Find first name under 5 letters long (using arrow function notation)',
},
{
example: "['Nathan', 'Bob', 'Sebastian'].find(function(name) { return name.length < 5 })",
evaluated: "'Bob'",
description: 'Or using traditional function notation',
},
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find',
returnType: 'Array | undefined',
args: [
{
name: 'function',
description: 'A function to run for each array element. As soon as it returns <code>true</code>, that element will be returned. Consider using <a target="_blank" href=”https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions”>arrow function notation</a> to save space.',
type: 'Function',
default: 'item => true',
args: [
{
name: 'element',
description: 'The value of the current element',
type: 'any',
},
{
name: 'index',
optional: true,
description: 'The position of the current element in the array (starting at 0)',
type: 'number',
},
{
name: 'array',
optional: true,
description: 'The array being processed. Rarely needed.',
type: 'Array',
},
{
name: 'thisValue',
optional: true,
description: 'A value passed to the function as its <code>this</code> value. Rarely needed.',
type: 'any',
},
],
},
],
},
},
findIndex: {
doc: {
name: 'findIndex',
hidden: true,
description: 'Returns the index of the first element in an array that passes the test `fn`. If none are found, -1 is returned.',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex',
returnType: 'number',
args: [{ name: 'fn', type: 'Function' }],
},
},
findLast: {
doc: {
name: 'findLast',
hidden: true,
description: 'Returns the value of the last element that passes the test `fn`.',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findLast',
returnType: 'any | undefined',
args: [{ name: 'fn', type: 'Function' }],
},
},
findLastIndex: {
doc: {
name: 'findLastIndex',
hidden: true,
description: 'Returns the index of the last element that satisfies the provided testing function. If none are found, -1 is returned.',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findLastIndex',
returnType: 'number',
args: [{ name: 'fn', type: 'Function' }],
},
},
indexOf: {
doc: {
name: 'indexOf',
description: "Returns the position of the first matching element in the array, or -1 if the element isn't found. Positions start at 0.",
examples: [
{ example: "['Bob', 'Bill', 'Nat'].indexOf('Nat')", evaluated: '2' },
{ example: "['Bob', 'Bill', 'Nat'].indexOf('Nathan')", evaluated: '-1' },
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf',
returnType: 'number',
args: [
{
name: 'element',
description: 'The value to look for',
type: 'any',
},
{
name: 'start',
optional: true,
description: 'The index to start looking from',
default: '0',
type: 'number',
},
],
},
},
includes: {
doc: {
name: 'includes',
description: 'Returns <code>true</code> if the array contains the specified element',
examples: [
{ example: "['Bob', 'Bill', 'Nat'].includes('Nat')", evaluated: 'true' },
{ example: "['Bob', 'Bill', 'Nat'].includes('Nathan')", evaluated: 'false' },
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes',
returnType: 'boolean',
args: [
{
name: 'element',
description: 'The value to search the array for',
type: 'any',
},
{
name: 'start',
optional: true,
description: 'The index to start looking from',
default: '0',
type: 'number',
},
],
},
},
join: {
doc: {
name: 'join',
description: 'Merges all elements of the array into a single string, with an optional separator between each element.\n\nThe opposite of <code>String.split()</code>.',
examples: [
{ example: "['Wind', 'Water', 'Fire'].join(' + ')", evaluated: "'Wind + Water + Fire'" },
{ example: "['Wind', 'Water', 'Fire'].join()", evaluated: "'Wind,Water,Fire'" },
{ example: "['Wind', 'Water', 'Fire'].join('')", evaluated: "'WindWaterFire'" },
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join',
returnType: 'string',
args: [
{
name: 'separator',
optional: true,
description: 'The character(s) to insert between each element',
default: "','",
type: 'string',
},
],
},
},
map: {
doc: {
name: 'map',
description: 'Creates a new array by applying a function to each element of the original array',
examples: [
{
example: '[12, 33, 16].map(num => num * 2)',
evaluated: '[24, 66, 32]',
description: 'Double all numbers (using arrow function notation)',
},
{
example: "['hello', 'old', 'chap'].map(word => word.toUpperCase())",
evaluated: "['HELLO', 'OLD', 'CHAP']]",
description: 'Convert elements to uppercase (using arrow function notation)',
},
{
example: "['hello', 'old', 'chap'].map(function(word) { return word.toUpperCase() })",
evaluated: "['HELLO', 'OLD', 'CHAP']]",
description: 'Or using traditional function notation',
},
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map',
returnType: 'Array',
args: [
{
name: 'function',
description: 'A function to run for each array element. In the new array, the output of this function takes the place of the element. Consider using <a target="_blank" href=”https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions”>arrow function notation</a> to save space.',
type: 'Function',
default: 'item => item',
args: [
{
name: 'element',
description: 'The value of the current element',
type: 'any',
},
{
name: 'index',
optional: true,
description: 'The position of the current element in the array (starting at 0)',
type: 'number',
},
{
name: 'array',
optional: true,
description: 'The array being processed. Rarely needed.',
type: 'Array',
},
{
name: 'thisValue',
optional: true,
description: 'A value passed to the function as its <code>this</code> value. Rarely needed.',
type: 'any',
},
],
},
],
},
},
reverse: {
doc: {
name: 'reverse',
description: 'Reverses the order of the elements in the array',
examples: [
{ example: "['dog', 'bites', 'man'].reverse()", evaluated: "['man', 'bites', 'dog']" },
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse',
returnType: 'Array',
},
},
reduce: {
doc: {
name: 'reduce',
description: 'Executes a "reducer" function `fn` on each element of the array. Passing in the return value from the calculation on the preceding element. The final result of running the reducer across all elements of the array is a single value.',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce',
returnType: 'any',
args: [
{
name: 'function',
description: 'A function to run for each array element. Takes the accumulated result and the current element, and returns a new accumulated result. Consider using <a target="_blank" href=”https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions”>arrow function notation</a> to save space.',
type: 'Function',
default: 'item => item',
args: [
{
name: 'prevResult',
description: 'The accumulated result from applying the function to previous elements. When processing the first element, it’s set to <code>initResult</code> (or the first array element if not specified).',
type: 'any',
},
{
name: 'currentElem',
description: 'The value in the array currently being processed',
type: 'any',
},
{
name: 'index',
optional: true,
description: 'The position of the current element in the array (starting at 0)',
type: 'number',
},
{
name: 'array',
optional: true,
description: 'The array being processed. Rarely needed.',
type: 'Array',
},
],
},
{
name: 'initResult',
optional: true,
description: "The initial value of the prevResult, used when calling the function on the first array element. When not specified it's set to the first array element, and the first function call is on the second array element instead of the first.",
type: 'any',
},
],
},
},
slice: {
doc: {
name: 'slice',
description: 'Returns a portion of the array, from the <code>start</code> index up to (but not including) the <code>end</code> index. Indexes start at 0.',
examples: [
{ example: '[1, 2, 3, 4, 5].slice(2, 4)', evaluated: '[3, 4]' },
{ example: '[1, 2, 3, 4, 5].slice(2)', evaluated: '[3, 4, 5]' },
{ example: '[1, 2, 3, 4, 5].slice(-2)', evaluated: '[4, 5]' },
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice',
returnType: 'Array',
args: [
{
name: 'start',
optional: true,
description: 'The position to start from. Positions start at 0. Negative numbers count back from the end of the array.',
default: '0',
type: 'number',
},
{
name: 'end',
optional: true,
description: 'The position to select up to. The element at the end position is not included. Negative numbers select from the end of the array. If omitted, will extract to the end of the array.',
type: 'number',
},
],
},
},
sort: {
doc: {
name: 'sort',
description: 'Reorders the elements of the array. For sorting strings alphabetically, no parameter is required. For sorting numbers or Objects, see examples.',
examples: [
{
example: "['d', 'a', 'c', 'b'].sort()",
evaluated: "['a', 'b', 'c', 'd']",
description: 'No need for a param when sorting strings',
},
{
example: '[4, 2, 1, 3].sort((a, b) => (a - b))',
evaluated: '[1, 2, 3, 4]',
description: 'To sort numbers, you must use a function',
},
{
example: '[4, 2, 1, 3].sort(function(a, b) { return a - b })',
evaluated: '[1, 2, 3, 4]',
description: 'Or using traditional function notation',
},
{ example: 'Sort in reverse alphabetical order' },
{ example: "arr = ['d', 'a', 'c', 'b']" },
{
example: 'arr.sort((a, b) => b.localeCompare(a))',
evaluated: "['d', 'c', 'b', 'a']",
description: 'Sort in reverse alphabetical order',
},
{
example: "[{name:'Zak'}, {name:'Abe'}, {name:'Bob'}].sort((a, b) => a.name.localeCompare(b.name))",
evaluated: "[{name:'Abe'}, {name:'Bob'}, {name:'Zak'}]",
description: 'Sort array of objects by a property',
},
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort',
returnType: 'Array',
args: [
{
name: 'compare',
optional: true,
description: 'A function to compare two array elements and return a number indicating which one comes first:\n<b>Return < 0</b>: <code>a</code> comes before <code>b</code>\n<b>Return 0</b>: <code>a</code> and <code>b</code> are equal (leave order unchanged)\n<b>Return > 0</b>: <code>b</code> comes before <code>a</code>\n\nIf no function is specified, converts all values to strings and compares their character codes.',
default: '""',
type: '(a, b) => number',
args: [
{
name: 'a',
description: 'The first element to compare in the function',
type: 'any',
},
{
name: 'b',
description: 'The second element to compare in the function',
type: 'any',
},
],
},
],
},
},
splice: {
doc: {
name: 'splice',
description: 'Changes the contents of an array by removing or replacing existing elements.',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice',
returnType: 'Array',
hidden: true,
args: [
{ name: 'start', type: 'number' },
{ name: 'deleteCount?', type: 'number' },
{ name: 'item1?', type: 'Element' },
{ name: '...' },
{ name: 'itemN?', type: 'Element' },
],
},
},
toString: {
doc: {
name: 'toString',
hidden: true,
description: 'Returns a string representing the specified array and its elements.',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString',
returnType: 'string',
},
},
toSpliced: {
doc: {
name: 'toSpliced',
description: 'Adds and/or removes array elements at a given position. \n\nSee also <code>slice()</code> and <code>append()</code>.',
examples: [
{
example: "['Jan', 'Mar'.toSpliced(1, 0, 'Feb')",
evaluated: "['Jan', 'Feb', 'Mar']",
description: 'Insert element at index 1',
},
{
example: '["don\'t", "make", "me", "do", "this"].toSpliced(1, 2)',
evaluated: '["don\'t", "do", "this"]',
description: 'Delete 2 elements starting at index 1',
},
{
example: '["don\'t", "be", "evil"].toSpliced(1, 2, "eat", "slugs")',
evaluated: '["don\'t", "eat", "slugs"]',
description: 'Replace 2 elements starting at index 1',
},
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toSpliced',
returnType: 'Array',
args: [
{
name: 'start',
description: 'The index (position) to add or remove elements at. New elements are inserted before the element at this index. A negative index counts back from the end of the array. ',
type: 'number',
},
{
name: 'deleteCount',
optional: true,
description: 'The number of elements to remove. If omitted, removes all elements from the <code>start</code> index onwards.',
type: 'number',
},
{
name: 'elements',
optional: true,
variadic: true,
description: 'The elements to be added, in order',
type: 'any',
},
],
},
},
},
};
});
//# sourceMappingURL=array.methods.js.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/array.methods.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

3
node_modules/n8n-workflow/dist/cjs/native-methods/boolean.methods.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import type { NativeDoc } from '../extensions/extensions';
export declare const booleanMethods: NativeDoc;
//# sourceMappingURL=boolean.methods.d.ts.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/boolean.methods.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"boolean.methods.d.ts","sourceRoot":"","sources":["../../../src/native-methods/boolean.methods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,eAAO,MAAM,cAAc,EAAE,SAkB5B,CAAC"}

31
node_modules/n8n-workflow/dist/cjs/native-methods/boolean.methods.js generated vendored Normal file
View File

@@ -0,0 +1,31 @@
(function (factory) {
if (typeof module === "object" && typeof module.exports === "object") {
var v = factory(require, exports);
if (v !== undefined) module.exports = v;
}
else if (typeof define === "function" && define.amd) {
define(["require", "exports"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.booleanMethods = void 0;
exports.booleanMethods = {
typeName: 'Boolean',
functions: {
toString: {
doc: {
name: 'toString',
description: "Converts <code>true</code> to the string <code>'true'</code> and <code>false</code> to the string <code>'false'</code>.",
examples: [
{ example: 'true.toString()', evaluated: "'true'" },
{ example: 'false.toString()', evaluated: "'false'" },
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/toString',
returnType: 'string',
},
},
},
};
});
//# sourceMappingURL=boolean.methods.js.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/boolean.methods.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"boolean.methods.js","sourceRoot":"","sources":["../../../src/native-methods/boolean.methods.ts"],"names":[],"mappings":";;;;;;;;;;;;IAEa,QAAA,cAAc,GAAc;QACxC,QAAQ,EAAE,SAAS;QACnB,SAAS,EAAE;YACV,QAAQ,EAAE;gBACT,GAAG,EAAE;oBACJ,IAAI,EAAE,UAAU;oBAChB,WAAW,EACV,yHAAyH;oBAC1H,QAAQ,EAAE;wBACT,EAAE,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,QAAQ,EAAE;wBACnD,EAAE,OAAO,EAAE,kBAAkB,EAAE,SAAS,EAAE,SAAS,EAAE;qBACrD;oBACD,MAAM,EACL,mGAAmG;oBACpG,UAAU,EAAE,QAAQ;iBACpB;aACD;SACD;KACD,CAAC"}

4
node_modules/n8n-workflow/dist/cjs/native-methods/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,4 @@
import type { NativeDoc } from '../extensions/extensions';
declare const NATIVE_METHODS: NativeDoc[];
export { NATIVE_METHODS as NativeMethods };
//# sourceMappingURL=index.d.ts.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/index.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/native-methods/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,QAAA,MAAM,cAAc,EAAE,SAAS,EAM9B,CAAC;AAEF,OAAO,EAAE,cAAc,IAAI,aAAa,EAAE,CAAC"}

27
node_modules/n8n-workflow/dist/cjs/native-methods/index.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
(function (factory) {
if (typeof module === "object" && typeof module.exports === "object") {
var v = factory(require, exports);
if (v !== undefined) module.exports = v;
}
else if (typeof define === "function" && define.amd) {
define(["require", "exports", "./array.methods", "./boolean.methods", "./number.methods", "./object.methods", "./string.methods"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.NativeMethods = void 0;
const array_methods_1 = require("./array.methods");
const boolean_methods_1 = require("./boolean.methods");
const number_methods_1 = require("./number.methods");
const object_methods_1 = require("./object.methods");
const string_methods_1 = require("./string.methods");
const NATIVE_METHODS = [
string_methods_1.stringMethods,
array_methods_1.arrayMethods,
number_methods_1.numberMethods,
object_methods_1.objectMethods,
boolean_methods_1.booleanMethods,
];
exports.NativeMethods = NATIVE_METHODS;
});
//# sourceMappingURL=index.js.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/index.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/native-methods/index.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,mDAA+C;IAC/C,uDAAmD;IACnD,qDAAiD;IACjD,qDAAiD;IACjD,qDAAiD;IAGjD,MAAM,cAAc,GAAgB;QACnC,8BAAa;QACb,4BAAY;QACZ,8BAAa;QACb,8BAAa;QACb,gCAAc;KACd,CAAC;IAEyB,uCAAa"}

3
node_modules/n8n-workflow/dist/cjs/native-methods/number.methods.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import type { NativeDoc } from '../extensions/extensions';
export declare const numberMethods: NativeDoc;
//# sourceMappingURL=number.methods.d.ts.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/number.methods.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"number.methods.d.ts","sourceRoot":"","sources":["../../../src/native-methods/number.methods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,eAAO,MAAM,aAAa,EAAE,SA0F3B,CAAC"}

95
node_modules/n8n-workflow/dist/cjs/native-methods/number.methods.js generated vendored Normal file
View File

@@ -0,0 +1,95 @@
(function (factory) {
if (typeof module === "object" && typeof module.exports === "object") {
var v = factory(require, exports);
if (v !== undefined) module.exports = v;
}
else if (typeof define === "function" && define.amd) {
define(["require", "exports"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.numberMethods = void 0;
exports.numberMethods = {
typeName: 'Number',
functions: {
toFixed: {
doc: {
name: 'toFixed',
hidden: true,
description: 'Formats a number using fixed-point notation. `digits` defaults to null if not given.',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toFixed',
returnType: 'string',
args: [{ name: 'digits?', type: 'number' }],
},
},
toPrecision: {
doc: {
name: 'toPrecision',
hidden: true,
description: 'Returns a string representing the number to the specified precision.',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toPrecision',
returnType: 'string',
args: [{ name: 'precision?', type: 'number' }],
},
},
toString: {
doc: {
name: 'toString',
description: 'Converts the number to a string. For more formatting options, see <code>toLocaleString()</code>.',
examples: [
{ example: '(2).toString()', evaluated: "'2'" },
{ example: '(50.125).toString()', evaluated: "'50.125'" },
{ example: '(5).toString(2)', evaluated: "'101'" },
{ example: '(412).toString(16)', evaluated: "'19c'" },
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString',
args: [
{
name: 'base',
optional: true,
description: 'The base to use. Must be an integer between 2 and 36. E.g. base <code>2</code> is binary and base <code>16</code> is hexadecimal.',
default: '10',
type: 'number',
},
],
returnType: 'string',
},
},
toLocaleString: {
doc: {
name: 'toLocaleString',
description: "Returns a localized string representing the number, i.e. in the language and format corresponding to its locale. Defaults to the system's locale if none specified.",
examples: [
{
example: '(500000.125).toLocaleString()',
evaluated: "'500,000.125' (if in US English locale)",
},
{ example: "(500000.125).toLocaleString('fr-FR')", evaluated: "'500 000,125'" },
{
example: "(500000.125).toLocaleString('fr-FR', {style:'currency', currency:'EUR'})",
evaluated: "'500 000,13 €'",
},
],
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString',
args: [
{
name: 'locale(s)',
optional: true,
description: 'The locale to use, e.g. \'en-GB\' for British English or \'pt-BR\' for Brazilian Portuguese. See <a target="_blank" href="https://www.localeplanet.com/icu/">full list</a> (unofficial). Also accepts an <a target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#locales_argument">array of locales</a>. Defaults to the system locale if not specified.',
type: 'string | string[]',
},
{
name: 'options',
optional: true,
description: 'An object with <a target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#parameters">formatting options</a>',
type: 'object',
},
],
returnType: 'string',
},
},
},
};
});
//# sourceMappingURL=number.methods.js.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/number.methods.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"number.methods.js","sourceRoot":"","sources":["../../../src/native-methods/number.methods.ts"],"names":[],"mappings":";;;;;;;;;;;;IAEa,QAAA,aAAa,GAAc;QACvC,QAAQ,EAAE,QAAQ;QAClB,SAAS,EAAE;YACV,OAAO,EAAE;gBACR,GAAG,EAAE;oBACJ,IAAI,EAAE,SAAS;oBACf,MAAM,EAAE,IAAI;oBACZ,WAAW,EACV,sFAAsF;oBACvF,MAAM,EACL,iGAAiG;oBAClG,UAAU,EAAE,QAAQ;oBACpB,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;iBAC3C;aACD;YACD,WAAW,EAAE;gBACZ,GAAG,EAAE;oBACJ,IAAI,EAAE,aAAa;oBACnB,MAAM,EAAE,IAAI;oBACZ,WAAW,EAAE,sEAAsE;oBACnF,MAAM,EACL,qGAAqG;oBACtG,UAAU,EAAE,QAAQ;oBACpB,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;iBAC9C;aACD;YACD,QAAQ,EAAE;gBACT,GAAG,EAAE;oBACJ,IAAI,EAAE,UAAU;oBAChB,WAAW,EACV,kGAAkG;oBACnG,QAAQ,EAAE;wBACT,EAAE,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,KAAK,EAAE;wBAC/C,EAAE,OAAO,EAAE,qBAAqB,EAAE,SAAS,EAAE,UAAU,EAAE;wBACzD,EAAE,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,OAAO,EAAE;wBAClD,EAAE,OAAO,EAAE,oBAAoB,EAAE,SAAS,EAAE,OAAO,EAAE;qBACrD;oBACD,MAAM,EACL,kGAAkG;oBACnG,IAAI,EAAE;wBACL;4BACC,IAAI,EAAE,MAAM;4BACZ,QAAQ,EAAE,IAAI;4BACd,WAAW,EACV,mIAAmI;4BACpI,OAAO,EAAE,IAAI;4BACb,IAAI,EAAE,QAAQ;yBACd;qBACD;oBACD,UAAU,EAAE,QAAQ;iBACpB;aACD;YACD,cAAc,EAAE;gBACf,GAAG,EAAE;oBACJ,IAAI,EAAE,gBAAgB;oBACtB,WAAW,EACV,qKAAqK;oBACtK,QAAQ,EAAE;wBACT;4BACC,OAAO,EAAE,+BAA+B;4BACxC,SAAS,EAAE,yCAAyC;yBACpD;wBACD,EAAE,OAAO,EAAE,sCAAsC,EAAE,SAAS,EAAE,eAAe,EAAE;wBAC/E;4BACC,OAAO,EAAE,0EAA0E;4BACnF,SAAS,EAAE,gBAAgB;yBAC3B;qBACD;oBACD,MAAM,EACL,wGAAwG;oBACzG,IAAI,EAAE;wBACL;4BACC,IAAI,EAAE,WAAW;4BACjB,QAAQ,EAAE,IAAI;4BACd,WAAW,EACV,iZAAiZ;4BAClZ,IAAI,EAAE,mBAAmB;yBACzB;wBACD;4BACC,IAAI,EAAE,SAAS;4BACf,QAAQ,EAAE,IAAI;4BACd,WAAW,EACV,4LAA4L;4BAC7L,IAAI,EAAE,QAAQ;yBACd;qBACD;oBACD,UAAU,EAAE,QAAQ;iBACpB;aACD;SACD;KACD,CAAC"}

3
node_modules/n8n-workflow/dist/cjs/native-methods/object.methods.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import type { NativeDoc } from '../extensions/extensions';
export declare const objectMethods: NativeDoc;
//# sourceMappingURL=object.methods.d.ts.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/object.methods.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"object.methods.d.ts","sourceRoot":"","sources":["../../../src/native-methods/object.methods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,eAAO,MAAM,aAAa,EAAE,SAG3B,CAAC"}

18
node_modules/n8n-workflow/dist/cjs/native-methods/object.methods.js generated vendored Normal file
View File

@@ -0,0 +1,18 @@
(function (factory) {
if (typeof module === "object" && typeof module.exports === "object") {
var v = factory(require, exports);
if (v !== undefined) module.exports = v;
}
else if (typeof define === "function" && define.amd) {
define(["require", "exports"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.objectMethods = void 0;
exports.objectMethods = {
typeName: 'Object',
functions: {},
};
});
//# sourceMappingURL=object.methods.js.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/object.methods.js.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"object.methods.js","sourceRoot":"","sources":["../../../src/native-methods/object.methods.ts"],"names":[],"mappings":";;;;;;;;;;;;IAEa,QAAA,aAAa,GAAc;QACvC,QAAQ,EAAE,QAAQ;QAClB,SAAS,EAAE,EAAE;KACb,CAAC"}

3
node_modules/n8n-workflow/dist/cjs/native-methods/string.methods.d.ts generated vendored Normal file
View File

@@ -0,0 +1,3 @@
import type { NativeDoc } from '../extensions/extensions';
export declare const stringMethods: NativeDoc;
//# sourceMappingURL=string.methods.d.ts.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/string.methods.d.ts.map generated vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"string.methods.d.ts","sourceRoot":"","sources":["../../../src/native-methods/string.methods.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAE1D,eAAO,MAAM,aAAa,EAAE,SA2hB3B,CAAC"}

499
node_modules/n8n-workflow/dist/cjs/native-methods/string.methods.js generated vendored Normal file
View File

@@ -0,0 +1,499 @@
(function (factory) {
if (typeof module === "object" && typeof module.exports === "object") {
var v = factory(require, exports);
if (v !== undefined) module.exports = v;
}
else if (typeof define === "function" && define.amd) {
define(["require", "exports"], factory);
}
})(function (require, exports) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.stringMethods = void 0;
exports.stringMethods = {
typeName: 'String',
properties: {
length: {
doc: {
name: 'length',
description: 'The number of characters in the string',
examples: [{ example: '"hello".length', evaluated: '5' }],
section: 'query',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length',
returnType: 'number',
},
},
},
functions: {
concat: {
doc: {
name: 'concat',
description: 'Joins one or more strings onto the end of the base string. Alternatively, use the <code>+</code> operator (see examples).',
examples: [
{ example: "'sea'.concat('food')", evaluated: "'seafood'" },
{ example: "'sea' + 'food'", evaluated: "'seafood'" },
{ example: "'work'.concat('a', 'holic')", evaluated: "'workaholic'" },
],
section: 'edit',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/concat',
args: [
{
name: 'strings',
optional: false,
variadic: true,
description: 'The strings to append, in order',
type: 'string[]',
},
],
returnType: 'string',
},
},
endsWith: {
doc: {
name: 'endsWith',
description: 'Returns <code>true</code> if the string ends with <code>searchString</code>. Case-sensitive.',
examples: [
{ example: "'team'.endsWith('eam')", evaluated: 'true' },
{ example: "'team'.endsWith('Eam')", evaluated: 'false' },
{
example: "'teaM'.toLowerCase().endsWith('eam')",
evaluated: 'true',
description: "Returns false if the case doesn't match, so consider using .toLowerCase() first",
},
],
section: 'query',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith',
returnType: 'boolean',
args: [
{
name: 'searchString',
optional: false,
description: 'The text to check against the end of the base string',
type: 'string',
},
{
name: 'end',
optional: true,
description: 'The end position (index) to start searching from',
type: 'number',
},
],
},
},
indexOf: {
doc: {
name: 'indexOf',
description: 'Returns the index (position) of the first occurrence of <code>searchString</code> within the base string, or -1 if not found. Case-sensitive.',
examples: [
{ example: "'steam'.indexOf('tea')", evaluated: '1' },
{ example: "'steam'.indexOf('i')", evaluated: '-1' },
{
example: "'STEAM'.indexOf('tea')",
evaluated: '-1',
description: "Returns -1 if the case doesn't match, so consider using .toLowerCase() first",
},
{ example: "'STEAM'.toLowerCase().indexOf('tea')", evaluated: '1' },
],
section: 'query',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf',
returnType: 'number',
args: [
{
name: 'searchString',
optional: false,
description: 'The text to search for',
type: 'string',
},
{
name: 'start',
optional: true,
description: 'The position (index) to start searching from',
default: '0',
type: 'number',
},
],
},
},
lastIndexOf: {
doc: {
name: 'lastIndexOf',
description: 'Returns the index (position) of the last occurrence of <code>searchString</code> within the base string, or -1 if not found. Case-sensitive.',
examples: [
{ example: "'canal'.lastIndexOf('a')", evaluated: '3' },
{ example: "'canal'.lastIndexOf('i')", evaluated: '-1' },
{
example: "'CANAL'.lastIndexOf('a')",
evaluated: '-1',
description: "Returns -1 if the case doesn't match, so consider using .toLowerCase() first",
},
{ example: "'CANAL'.toLowerCase().lastIndexOf('a')", evaluated: '3' },
],
section: 'query',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf',
returnType: 'number',
args: [
{
name: 'searchString',
optional: false,
description: 'The text to search for',
type: 'string',
},
{
name: 'end',
optional: true,
description: 'The position (index) to stop searching at',
default: '0',
type: 'number',
},
],
},
},
match: {
doc: {
name: 'match',
description: 'Matches the string against a <a target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions">regular expression</a>. Returns an array containing the first match, or all matches if the <code>g</code> flag is set in the regular expression. Returns <code>null</code> if no matches are found. \n\nFor checking whether text is present, consider <code>includes()</code> instead.',
examples: [
{
example: '"rock and roll".match(/r[^ ]*/g)',
evaluated: "['rock', 'roll']",
description: "Match all words starting with 'r'",
},
{
example: '"rock and roll".match(/r[^ ]*/)',
evaluated: "['rock']",
description: "Match first word starting with 'r' (no 'g' flag)",
},
{
example: '"ROCK and roll".match(/r[^ ]*/ig)',
evaluated: "['ROCK', 'roll']",
description: "For case-insensitive, add 'i' flag",
},
],
section: 'query',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/match',
returnType: 'string[]',
args: [
{
name: 'regexp',
optional: false,
description: 'A <a target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions">regular expression</a> with the pattern to look for. Will look for multiple matches if the <code>g</code> flag is present (see examples).',
type: 'RegExp',
},
],
},
},
includes: {
doc: {
name: 'includes',
description: 'Returns <code>true</code> if the string contains the <code>searchString</code>. Case-sensitive.',
section: 'query',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes',
returnType: 'boolean',
args: [
{
name: 'searchString',
optional: false,
description: 'The text to search for',
type: 'string',
},
{
name: 'start',
optional: true,
description: 'The position (index) to start searching from',
default: '0',
type: 'number',
},
],
examples: [
{ example: "'team'.includes('tea')", evaluated: 'true' },
{ example: "'team'.includes('i')", evaluated: 'false' },
{
example: "'team'.includes('Tea')",
evaluated: 'false',
description: "Returns false if the case doesn't match, so consider using .toLowerCase() first",
},
{ example: "'Team'.toLowerCase().includes('tea')", evaluated: 'true' },
],
},
},
replace: {
doc: {
name: 'replace',
description: 'Returns a string with the first occurrence of <code>pattern</code> replaced by <code>replacement</code>. \n\nTo replace all occurrences, use <code>replaceAll()</code> instead.',
section: 'edit',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace',
returnType: 'string',
args: [
{
name: 'pattern',
optional: false,
description: 'The pattern in the string to replace. Can be a string to match or a <a target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions">regular expression</a>.',
type: 'string|RegExp',
},
{
name: 'replacement',
optional: false,
description: 'The new text to replace with',
type: 'string',
},
],
examples: [
{
example: "'Red or blue or green'.replace('or', 'and')",
evaluated: "'Red and blue or green'",
},
{
example: 'let text = "Mr Blue has a blue house and a blue car";\ntext.replace(/blue/gi, "red");',
evaluated: "'Mr red has a red house and a red car'",
description: 'A global, case-insensitive replacement:',
},
{
example: 'let text = "Mr Blue has a blue house and a blue car";\ntext.replace(/blue|house|car/gi, (t) => t.toUpperCase());',
evaluated: "'Mr BLUE has a BLUE HOUSE and a BLUE CAR'",
description: 'A function to return the replacement text:',
},
],
},
},
replaceAll: {
doc: {
name: 'replaceAll',
description: 'Returns a string with all occurrences of <code>pattern</code> replaced by <code>replacement</code>',
examples: [
{
example: "'Red or blue or green'.replaceAll('or', 'and')",
evaluated: "'Red and blue and green'",
},
{
example: "text = 'Mr Blue has a blue car';\ntext.replaceAll(/blue|car/gi, t => t.toUpperCase())",
description: "Uppercase any occurrences of 'blue' or 'car' (You must include the 'g' flag when using a regex)",
evaluated: "'Mr BLUE has a BLUE CAR'",
},
{
example: 'text.replaceAll(/blue|car/gi, function(x){return x.toUpperCase()})',
evaluated: "'Mr BLUE has a BLUE CAR'",
description: 'Or with traditional function notation:',
},
],
section: 'edit',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replaceAll',
returnType: 'string',
args: [
{
name: 'pattern',
optional: false,
description: 'The pattern in the string to replace. Can be a string to match or a <a target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions">regular expression</a>.',
type: 'string|RegExp',
},
{
name: 'replacement',
optional: false,
description: 'The new text to replace with. Can be a string or a function that returns a string (see examples).',
type: 'string|Function',
},
],
},
},
search: {
doc: {
name: 'search',
description: 'Returns the index (position) of the first occurrence of a pattern within the string, or -1 if not found. The pattern is specified using a <a target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions">regular expression</a>. To use text instead, see <code>indexOf()</code>.',
examples: [
{
example: '"Neat n8n node".search(/n[^ ]*/)',
evaluated: '5',
description: "Pos of first word starting with 'n'",
},
{
example: '"Neat n8n node".search(/n[^ ]*/i)',
evaluated: '0',
description: "Case-insensitive match with 'i'\nPos of first word starting with 'n' or 'N'",
},
],
section: 'query',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/search',
returnType: 'string',
args: [
{
name: 'regexp',
optional: false,
description: 'A <a target="_blank" href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions">regular expression</a> with the pattern to look for',
type: 'RegExp',
},
],
},
},
slice: {
doc: {
name: 'slice',
description: 'Extracts a fragment of the string at the given position. For more advanced extraction, see <code>match()</code>.',
examples: [
{ example: "'Hello from n8n'.slice(0, 5)", evaluated: "'Hello'" },
{ example: "'Hello from n8n'.slice(6)", evaluated: "'from n8n'" },
{ example: "'Hello from n8n'.slice(-3)", evaluated: "'n8n'" },
],
section: 'edit',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/slice',
returnType: 'string',
args: [
{
name: 'start',
optional: false,
description: 'The position to start from. Positions start at 0. Negative numbers count back from the end of the string.',
type: 'number',
},
{
name: 'end',
optional: true,
description: 'The position to select up to. The character at the end position is not included. Negative numbers select from the end of the string. If omitted, will extract to the end of the string.',
type: 'string',
},
],
},
},
split: {
doc: {
name: 'split',
description: "Splits the string into an array of substrings. Each split is made at the <code>separator</code>, and the separator isn't included in the output. \n\nThe opposite of using <code>join()</code> on an array.",
examples: [
{ example: '"wind,fire,water".split(",")', evaluated: "['wind', 'fire', 'water']" },
{ example: '"me and you and her".split("and")', evaluated: "['me ', ' you ', ' her']" },
{
example: '"me? you, and her".split(/[ ,?]+/)',
evaluated: "['me', 'you', 'and', 'her']",
description: "Split one or more of space, comma and '?' using a regular expression",
},
],
section: 'edit',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split',
returnType: 'string[]',
args: [
{
name: 'separator',
optional: true,
description: 'The string (or regular expression) to use for splitting. If omitted, an array with the original string is returned.',
type: 'string',
},
{
name: 'limit',
optional: true,
description: 'The max number of array elements to return. Returns all elements if omitted.',
type: 'number',
},
],
},
},
startsWith: {
doc: {
name: 'startsWith',
description: 'Returns <code>true</code> if the string starts with <code>searchString</code>. Case-sensitive.',
examples: [
{ example: "'team'.startsWith('tea')", evaluated: 'true' },
{ example: "'team'.startsWith('Tea')", evaluated: 'false' },
{
example: "'Team'.toLowerCase().startsWith('tea')",
evaluated: 'true',
description: "Returns false if the case doesn't match, so consider using .toLowerCase() first",
},
],
section: 'query',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith',
returnType: 'boolean',
args: [
{
name: 'searchString',
optional: false,
description: 'The text to check against the start of the base string',
type: 'string',
},
{
name: 'start',
optional: true,
description: 'The position (index) to start searching from',
default: '0',
type: 'number',
},
],
},
},
substring: {
doc: {
name: 'substring',
description: 'Extracts a fragment of the string at the given position. For more advanced extraction, see <code>match()</code>.',
examples: [
{ example: "'Hello from n8n'.substring(0, 5)", evaluated: "'Hello'" },
{ example: "'Hello from n8n'.substring(6)", evaluated: "'from n8n'" },
],
section: 'edit',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring',
returnType: 'string',
args: [
{
name: 'start',
optional: false,
description: 'The position to start from. Positions start at 0.',
type: 'number',
},
{
name: 'end',
optional: true,
description: 'The position to select up to. The character at the end position is not included. If omitted, will extract to the end of the string.',
type: 'string',
},
],
},
},
toLowerCase: {
doc: {
name: 'toLowerCase',
description: 'Converts all letters in the string to lower case',
section: 'case',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase',
returnType: 'string',
examples: [{ example: '"I\'m SHOUTing".toLowerCase()', evaluated: '"i\'m shouting"' }],
},
},
toUpperCase: {
doc: {
name: 'toUpperCase',
description: 'Converts all letters in the string to upper case (capitals)',
examples: [{ example: '"I\'m not angry".toUpperCase()', evaluated: '"I\'M NOT ANGRY"' }],
section: 'case',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase',
returnType: 'string',
},
},
trim: {
doc: {
name: 'trim',
description: 'Removes whitespace from both ends of the string. Whitespace includes new lines, tabs, spaces, etc.',
examples: [{ example: "' lonely '.trim()", evaluated: "'lonely'" }],
section: 'edit',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim',
returnType: 'string',
},
},
trimEnd: {
doc: {
name: 'trimEnd',
description: 'Removes whitespace from the end of a string and returns a new string. Whitespace includes new lines, tabs, spaces, etc.',
examples: [{ example: "' lonely '.trimEnd()", evaluated: "' lonely'" }],
section: 'edit',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trimEnd',
returnType: 'string',
},
},
trimStart: {
doc: {
name: 'trimStart',
description: 'Removes whitespace from the beginning of a string and returns a new string. Whitespace includes new lines, tabs, spaces, etc.',
examples: [{ example: "' lonely '.trimStart()", evaluated: "'lonely '" }],
section: 'edit',
docURL: 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/trimStart',
returnType: 'string',
},
},
},
};
});
//# sourceMappingURL=string.methods.js.map

1
node_modules/n8n-workflow/dist/cjs/native-methods/string.methods.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long