List

62 nodes. Types ending in [] are lists. An input with a default is optional.

Nodes

List.AddItemToEnd

Appends a value to the end of a list (returns a new list).

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to append to.
item required	any	—	The value to append.

Outputs

Output	Type	What it gives
list	any[]	A new list with the value appended.

Tags: append push add

List.AddItemToFront

Returns a new list with the value prepended — the front-side twin of List.AddItemToEnd.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to extend.
item required	any	—	The value to prepend.

Outputs

Output	Type	What it gives
list	any[]	A new list with the element first.

Tags: add prepend front first push

List.AllIndicesOf

Every zero-based index at which the item occurs in the list — List.IndexOf finds only the first. Values compare as in List.IndexOf. Feed the indices to List.GetItemAtIndex on a parallel list to pull the matching entries.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to search.
item required	any	—	The value to look for (value equality, like List.IndexOf).

Outputs

Output	Type	What it gives
indices	integer[]	The zero-based indices of every occurrence (empty when absent).

Tags: indices index all occurrences find positions where

List.AllTrue

True when EVERY element of the list is true — collapse a mask into one verdict. Only the booleans true and false (or the text "true" and "false") count: an empty list gives false, null items count as not true, and any other value (a number, other text) counts as not true and adds a warning. A list inside the list is an error: set the input to @L2 for one verdict per sublist, or flatten it first. A wire that delivers nothing at all is ignored.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The booleans to test: only true counts as true; nulls and anything that is not true or false count as not-true, and a nested list is an error.

Outputs

Output	Type	What it gives
allTrue	boolean	True when every element is true (and the list is not empty).

Tags: all true every and mask verdict

List.AnyTrue

True when AT LEAST ONE element of the list is true — "did anything match?" in one node. Only the booleans true and false (or the text "true" and "false") count: an empty list gives false, null items count as not true, and any other value (a number, other text) counts as not true and adds a warning. A list inside the list is an error: set the input to @L2 for one answer per sublist, or flatten it first. A wire that delivers nothing at all is ignored.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The booleans to test: only true counts as true; nulls and anything that is not true or false count as not-true, and a nested list is an error.

Outputs

Output	Type	What it gives
anyTrue	boolean	True when at least one element is true.

Tags: any true some or mask exists

List.Chop

Chops a list into consecutive sublists: one length chops evenly ([1..7] by 3 → [1,2,3],[4,5,6],[7]); a list of lengths is applied in sequence and repeats until the input runs out (Dynamo behavior). Every length must be a whole number of at least 1.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to chop.
lengths required	any[]	—	Sublist length(s): one number chops evenly; a list of numbers is applied in sequence and repeats until the list is used up.

Outputs

Output	Type	What it gives
lists	any[]	The sublists (the last one may be shorter).

Tags: chop split partition chunk sublists group

List.Clean

Removes null elements from a list, at every nesting level — the mop-up after laced calls that emitted nulls for missing elements (a yellow node badge points here). removeEmptyLists also drops sublists left empty. Dynamo users: same idea as List.Clean.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to clean (nested lists are cleaned recursively).
removeEmptyLists	boolean	true	True also drops sublists that are (or become) empty; false keeps them as empty lists.

Outputs

Output	Type	What it gives
list	any[]	The cleaned list.

Tags: clean null remove nulls compact purge empty filter

List.Contains

Tests whether a list contains a value. Numbers compare by value regardless of numeric type, text with its case, and a list or dictionary by its content, so a [level, type] pair can be looked up too.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to search.
item required	any	—	The value to look for.

Outputs

Output	Type	What it gives
contains	boolean	True when the value occurs in the list.

Tags: membership includes has any

List.Count

Returns the number of elements in a list.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to count.

Outputs

Output	Type	What it gives
count	integer	The element count.

Tags: length size

List.CountTrue

Counts the true and not-true elements of a mask — "37 of 340 matched" for reports without filtering first. Only the booleans true and false (or the text "true" and "false") count as true or false: null items and any other value (a number, other text) go into the not-true count, and a value that is not a boolean adds a warning. A list inside the list is an error: set the input to @L2 for one count per sublist, or flatten it first. A wire that delivers nothing at all is ignored.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The booleans to count: only true counts as true; nulls and anything that is not true or false count as not-true, and a nested list is an error.

Outputs

Output	Type
trueCount	integer
falseCount	integer

Returns: The true and not-true counts.

Tags: count true false mask tally how many

List.Create

Builds a list from the wired item inputs, in order. A wired list is kept whole as ONE item of the new list (a list of lists); List.Merge joins lists into one list instead.

Interactive node: it has its own controls on the canvas.

Inputs

Input	Type	Default	What it does
item0 … itemN required	any	—	Wire any number of items — a fresh empty input appears as you connect.

Outputs

Output	Type	What it gives
list	any[]	The created list.

Tags: array collection build make items combine

List.Cycle

Repeats the whole list a number of times, end-to-end ([a,b] × 3 → [a,b,a,b,a,b]). The result may hold at most 1,000,000 items; more is an error.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to repeat.
amount required	integer	—	How many copies to chain (≥ 0); the result may hold at most one million items.

Outputs

Output	Type	What it gives
list	any[]	The list repeated end-to-end.

Tags: cycle repeat tile loop duplicate

List.DropItems

Drops elements from the start of the list — or from the END with a negative amount (Dynamo behavior). Dropping more than the length gives an empty list.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to shorten.
amount required	integer	—	How many elements to drop: positive from the start, negative from the end.

Outputs

Output	Type	What it gives
list	any[]	The shortened list (empty when the amount exceeds the length).

Tags: drop skip remove trim start end

List.DropWhile

Drops items from the start of the list for as long as the mask is true; keeps everything from the first false. The mask is read as in List.FilterByBoolMask: one true or false per item, a null counts as false, and a list or a value that is not true or false is an error.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The items.
mask required	any[]	—	One true/false per item (same length).

Outputs

Output	Type	What it gives
list	any[]	The items from the first false on.

Tags: skip leading tail prefix

List.FilterByBoolMask

Splits a list into elements whose mask entry is true ("in") and the rest ("out"). The mask must have one entry per element: true or false, the text "true" or "false", or a number (0 is false, any other number true); an empty entry (null) counts as false, so the element goes to "out". A list or dictionary in the mask is an error: set both inputs to @L2 (right-click, List Levels) to filter each pair of sublists, or flatten them first.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to filter.
mask required	any[]	—	Booleans (or values coercible to booleans), one per element.

Outputs

Output	Type
in	any
out	any

Returns: Dictionary with "in" and "out" lists.

Tags: filter mask partition sieve

List.FilterByValue

Keeps the items that pass a test such as > 100, contains "wall", matches "A-*" or in ["L01", "L02"] — optionally testing a parallel list of keys instead; returns the matches, the rest and the mask. The tests > >= < <= never pass an item that has no value (null or blank text) or one that cannot be compared with the value (text against a number; the node then warns and names the first). The test in keeps the items equal to any of the values in a list (or in a text with the values separated by commas or semicolons); notIn keeps the others. Text tests ignore case unless ignoreCase is off; regex needs a pattern of its own and stops after 2 seconds.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The items to filter.
test	string	"=="	The test: ==, !=, >, >=, <, <=, contains, !contains, startsWith, endsWith, matches (wildcards * and ?), regex, isNull, notNull, isEmpty, notEmpty, in, notIn.
value	any	null	What to test against (not used by the isNull / notNull / isEmpty / notEmpty tests). For in and notIn a list of values, or a text with the values separated by commas or semicolons.
keys	any[]	null	Optional: a list of the same length whose values are tested instead of the items themselves (filter model items by a property value).
ignoreCase	boolean	true	True (default) ignores upper/lower case in text tests.

Outputs

Output	Type
matched	any
rejected	any
mask	boolean[]

Returns: The items that passed, the items that did not, and the true/false mask.

Tags: filter where select keep compare mask search query in any of one of membership

List.FirstItem

Returns the first element of a list. An empty list is an error: there is no first element (check List.Count first, or use List.Slice, which gives an empty list).

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to read from (must not be empty).

Outputs

Output	Type	What it gives
item	any	The first element.

Tags: head front

List.Flatten

Flattens a nested list by a given number of levels (-1 = completely).

Inputs

Input	Type	Default	What it does
list required	any[]	—	The (possibly nested) list to flatten.
amount	integer	-1	Levels of nesting to remove; -1 flattens completely.

Outputs

Output	Type	What it gives
list	any[]	The flattened list.

Tags: nested unwrap

List.GetItemAtIndex

Returns the element at the given index (negative indexes count from the end).

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to read from.
index required	integer	—	Zero-based index; negative values count from the end.

Outputs

Output	Type	What it gives
item	any	The element at the index.

Tags: element at index pick

List.GroupByKey

Groups list elements by a parallel key list of the same length; returns the groups (in the order each key first appears) and their unique keys. A key can be a list, such as [level, type], and two keys with the same content make one group; text keys keep their case.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The elements to group.
keys required	any[]	—	One key per element.

Outputs

Output	Type
groups	any
uniqueKeys	any

Returns: Dictionary with "groups" (list of lists) and "uniqueKeys".

Tags: group bucket categorize partition

List.IndexOf

Returns the index of the first occurrence of a value in a list (-1 when absent). Numbers compare by value, text with its case, and lists and dictionaries by their content.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to search.
item required	any	—	The value to look for.

Outputs

Output	Type	What it gives
index	integer	The zero-based index, or -1 when not found.

Tags: find position locate search

List.Insert

Returns a new list with the value inserted at the index (0 = front; the list's length = append; negative counts from the end). A list of indices makes one new list per index; the list itself is always taken whole.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to edit.
item required	any	—	The value to insert.
index required	integer	—	Zero-based position for the new element (0 = front, Count = end; negative counts from the end).

Outputs

Output	Type	What it gives
list	any[]	A new list with the element inserted.

Tags: insert add index position

List.LastIndexOf

The zero-based index of the LAST occurrence of the item (-1 when absent) — the back-to-front twin of List.IndexOf, with the same rules for comparing values.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to search.
item required	any	—	The value to look for (value equality).

Outputs

Output	Type	What it gives
index	integer	The zero-based index of the last occurrence, or -1 when absent.

Tags: index last find position reverse

List.LastItem

Returns the last element of a list. An empty list is an error: there is no last element (check List.Count first, or use List.Slice, which gives an empty list).

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to read from (must not be empty).

Outputs

Output	Type	What it gives
item	any	The last element.

Tags: tail end final

List.MaximumItem

The largest element of a list (numbers, texts or dates). Items are compared as in List.Sort: numbers by value, text ignoring case ("10" and "9" are text, so "9" is the larger; List.Statistics reads such text as numbers); nulls and empty text are ignored. A list with nothing to compare gives an empty result and a warning, not an error.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The list to scan (nulls and empty text are ignored); with none left the result is empty and the node warns.

Outputs

Output	Type	What it gives
item	any	The maximum element.

Tags: maximum max largest biggest highest

List.Merge

Concatenates any number of lists into one — a multi-input socket: connect as many wires as you like, in the order you want them.

Inputs

Input	Type	Default	What it does
lists any number of wires required	any[]	—	Every list wired to the socket; list-valued wires contribute their elements, other values themselves.

Outputs

Output	Type	What it gives
list	any[]	A new list with the elements of all the wires, in wire order.

Tags: concat combine join append many multi

List.MinimumItem

The smallest element of a list (numbers, texts or dates). Items are compared as in List.Sort: numbers by value, text ignoring case ("10" and "9" are text, so "10" is the smaller; List.Statistics reads such text as numbers); nulls and empty text are ignored. A list with nothing to compare gives an empty result and a warning, not an error.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The list to scan (nulls and empty text are ignored); with none left the result is empty and the node warns.

Outputs

Output	Type	What it gives
item	any	The minimum element.

Tags: minimum min smallest lowest

List.OfRepeatedItem

A list of one value repeated N times — constant columns for tables, or a fixed pairing partner under Longest lacing. At most 1,000,000 copies; more is an error.

Inputs

Input	Type	Default	What it does
item required	any	—	The value to repeat.
amount required	integer	—	How many copies (≥ 0, at most one million).

Outputs

Output	Type	What it gives
list	any[]	The repeated-value list.

Tags: repeat repeated fill constant duplicate

List.Pairs

Pairs each item with the next one: [[a, b], [b, c], …] — consecutive points, segments, steps.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list.
cyclic	boolean	false	True also pairs the last item with the first.

Outputs

Output	Type	What it gives
pairs	any[]	[item0, item1], [item1, item2], … (one pair fewer than items, or as many with 'cyclic').

Tags: neighbours consecutive segments window adjacent

List.Range

Creates a sequence of numbers from start to end (both included) using the given step; a negative step counts down, a step that moves away from end gives an empty list. Each number is start + n x step, so 0.1 steps do not drift. At most 1,000,000 numbers: a larger sequence is an error, so a slip of a zero cannot use up the memory of Navisworks.

Inputs

Input	Type	Default	What it does
start required	number	—	First value of the sequence.
end required	number	—	Inclusive upper (or lower, for negative steps) bound.
step	number	1	Increment between values; may be negative.

Outputs

Output	Type	What it gives
list	number[]	The sequence as a list of numbers.

Tags: sequence series numbers

List.RemoveItemAtIndex

Removes the elements at the given indices and returns one new list (negative indexes count from the end). Wire a single number to remove one element, or a list of numbers, for example from List.AllIndicesOf, to remove them all in one go. Indices count in the original list; an index outside the list is an error.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to remove from.
indices required	integer[]	—	Zero-based indices of the elements to remove; negative values count from the end. A single number works too. The same index twice removes the element once.

Outputs

Output	Type	What it gives
list	any[]	A new list without the elements.

Tags: delete drop without

List.ReplaceItemAtIndex

Returns a new list with the element at the index replaced (negative indexes count from the end). A list of indices makes one new list per index (the first index with the first item, and so on); the list itself is always taken whole.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to edit.
index required	integer	—	Zero-based index; negative values count from the end.
item required	any	—	The replacement value.

Outputs

Output	Type	What it gives
list	any[]	A new list with the element replaced.

Tags: replace item index set edit

List.ReplaceNulls

Replaces every null element with a substitute value, at every nesting level — keeps list lengths and alignment intact where List.Clean would shift them. The gap-filler for laced calls that emitted nulls (0 for math, "n/a" for reports).

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to patch (nested lists are patched recursively).
substitute required	any	—	The value to put where a null sits (e.g. 0, "" or "n/a").

Outputs

Output	Type	What it gives
list	any[]	The patched list, same shape as the input.

Tags: replace null nulls substitute default fill patch

List.RestOfItems

Everything but the first element — pairs with List.FirstItem for head/tail processing. An empty list is an error: there is no first element to leave out.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to read from (must not be empty).

Outputs

Output	Type	What it gives
list	any[]	The list without its first element.

Tags: rest tail skip first

List.Reverse

Returns the list in reverse order.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to reverse.

Outputs

Output	Type	What it gives
list	any[]	A new list in reverse order.

Tags: flip invert backwards

List.SetDifference

The distinct elements of the FIRST list that are NOT in the second — subtract an ignore-list from a result set. Values compare as in List.UniqueItems, lists and dictionaries by content.

Inputs

Input	Type	Default	What it does
list1 required	any[]	—	The list to start from.
list2 required	any[]	—	The elements to remove.

Outputs

Output	Type	What it gives
list	any[]	The difference, ordered as in the first list.

Tags: difference set subtract except remove without

List.SetIntersection

The distinct elements present in BOTH lists (ordered as in the first) — what two searches/sets have in common. Values compare as in List.UniqueItems, lists and dictionaries by content.

Inputs

Input	Type	Default	What it does
list1 required	any[]	—	The first list.
list2 required	any[]	—	The second list.

Outputs

Output	Type	What it gives
list	any[]	The intersection, ordered as in the first list.

Tags: intersection set common both and overlap

List.SetUnion

The distinct elements present in EITHER list (first-seen order) — combine two item sets without duplicates. Values compare as in List.UniqueItems, lists and dictionaries by content.

Inputs

Input	Type	Default	What it does
list1 required	any[]	—	The first list.
list2 required	any[]	—	The second list.

Outputs

Output	Type	What it gives
list	any[]	The union, first-seen order, duplicates removed.

Tags: union set combine merge distinct or

List.ShiftIndices

Rotates the list: +1 moves every element one place towards the end and wraps the last to the front ([a,b,c] → [c,a,b]); negative rotates the other way.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to rotate.
amount required	integer	—	Positive moves elements towards the end (the last wraps to the front); negative the other way.

Outputs

Output	Type	What it gives
list	any[]	The rotated list.

Tags: shift rotate wrap offset roll

List.Shuffle

Shuffles a list; the same seed always gives the same order, so a run can be repeated.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list.
seed	integer	0	Same seed, same order; change it for a different order.

Outputs

Output	Type	What it gives
list	any[]	A shuffled copy.

Tags: random mix sample permute

List.Slice

A sub-range of the list: from start (inclusive) to end (exclusive), taking every step-th element; leave end empty to go to the end of the list. Negative start/end count from the end, Python-style. Start 0 with a step of 3 keeps the 1st, 4th, 7th ... item, which is how to thin a list out.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to read from.
start required	integer	—	First index of the range (inclusive; negative counts from the end).
end	integer	null	End of the range (exclusive; negative counts from the end); leave it unset to go to the end of the list.
step	integer	1	Take every step-th element of the range (≥ 1).

Outputs

Output	Type	What it gives
list	any[]	The sub-list.

Tags: slice range sub subset portion between thin to the end

List.Sort

Returns the list sorted ascending, or largest first with descending. Numbers sort by value; text alphabetically, ignoring upper and lower case ("apple" comes before "Zebra", and "10" before "9" because both are text); text that reads as a number counts as a number against a number; empty items (null or empty text) always go last, in either direction. Equal items keep their order. A list inside the list cannot be put in order: set the input to @L2 to sort each sublist.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to sort.
descending	boolean	false	True sorts largest first; empty items stay last.

Outputs

Output	Type	What it gives
list	any[]	A new sorted list.

Tags: order ascending arrange descending reverse biggest first top sortdescending

List.SortByKey

Sorts list elements by a parallel key list of the same length, smallest key first or largest first with descending; returns the sorted elements and keys. Keys are put in order as in List.Sort (numbers by value, text ignoring case, empty keys last); elements with equal keys keep their order.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The elements to sort.
keys required	any[]	—	One sort key per element.
descending	boolean	false	True sorts the largest key first; elements with an empty key stay last.

Outputs

Output	Type
sorted	any
sortedKeys	any

Returns: Dictionary with "sorted" elements and the "sortedKeys".

Tags: order arrange rank key descending

List.TakeEveryNthItem

Takes the n-th, 2n-th, 3n-th ... element, optionally after skipping offset elements (n = 3 takes the 3rd, 6th and 9th, which are the indices 2, 5 and 8). To keep the 1st, 4th, 7th ... instead, use List.Slice with a step.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to sample.
n required	integer	—	Take every n-th element (≥ 1).
offset	integer	0	Elements to skip before counting starts.

Outputs

Output	Type	What it gives
list	any[]	The sampled elements.

Tags: every nth sample skip thin step

List.TakeItems

Takes elements from the start of the list — or from the END with a negative amount (Dynamo behavior). Taking more than the length gives the whole list.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to read from.
amount required	integer	—	How many elements to keep: positive from the start, negative from the end.

Outputs

Output	Type	What it gives
list	any[]	The taken elements (the whole list when the amount exceeds the length).

Tags: take first head keep start end

List.TakeWhile

Takes items from the start of the list for as long as the mask is true (stops at the first false). The mask is read as in List.FilterByBoolMask: one true or false per item, a null counts as false, and a list or a value that is not true or false is an error.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The items.
mask required	any[]	—	One true/false per item (same length).

Outputs

Output	Type	What it gives
list	any[]	The items before the first false.

Tags: head until leading prefix

List.Transpose

Swaps rows and columns of a list of lists — the table pivot for Excel/CSV data and property grids. Shorter rows pad with nulls so the result stays rectangular (Dynamo behavior); List.Clean or List.ReplaceNulls deal with the padding.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list of rows.

Outputs

Output	Type	What it gives
lists	any[]	The transposed list; shorter rows are padded with nulls so the result is rectangular (Dynamo behavior).

Tags: transpose rows columns pivot swap table matrix

List.UniqueItems

Removes duplicate elements from a list, keeping the first of each and the original order. Numbers compare by value, text with its case, and lists and dictionaries by their content, so repeated pairs from List.Zip are removed too.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list to deduplicate.

Outputs

Output	Type	What it gives
list	any[]	A new list with duplicates removed, in original order.

Tags: distinct deduplicate unique

List.WithIndex

Pairs each item with its position: [[0, item0], [1, item1], …].

Inputs

Input	Type	Default	What it does
list required	any[]	—	The list.

Outputs

Output	Type	What it gives
pairs	any[]	A list of [index, item] pairs, indexes starting at 0.

Tags: enumerate index number position row number

List.Zip

Pairs two lists by position: [[a0, b0], [a1, b1], …], as long as the shorter list. When the lists differ in length the extra items of the longer one are left out and the node shows a warning that says how many.

Inputs

Input	Type	Default	What it does
first required	any[]	—	The first list.
second required	any[]	—	The second list.

Outputs

Output	Type	What it gives
pairs	any[]	[first0, second0], [first1, second1], … as long as the shorter list.

Tags: pair combine merge interleave together

Statistics

List.Average

The arithmetic mean of the numbers of a list. Nulls and blank text are skipped; with no numbers at all (an empty list) the result is empty and the node shows a warning instead of an error. A list inside the list is an error: set the input to @L2 for one average per sublist.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The numbers (nulls and blank text are skipped).

Outputs

Output	Type	What it gives
average	number	The arithmetic mean; empty (with a warning) when the list has no numbers.

Tags: mean aggregate avg kpi

List.CountValues

Tallies a list: each distinct value, in order of first appearance, with the number of times it occurs. Numbers compare by value, text with its case, and lists and dictionaries by their content. (It tallies the values themselves; List.GroupByKey groups items by a separate list of keys.)

Inputs

Input	Type	Default	What it does
list required	any[]	—	The values to tally (nulls are counted as one value, shown empty).

Outputs

Output	Type
values	any
counts	integer[]

Returns: The distinct values in order of first appearance and how many times each occurs.

Tags: tally frequency distribution group count how many of each countby count by

List.CumulativeSum

A running total: each item is the sum of the list up to and including that position. An empty item (null or blank text) is an error, so the totals stay lined up with the list; remove or fill empty items first (List.FilterByValue with the notEmpty test, or List.ReplaceNulls). A list inside the list is an error: set the input to @L2 for one running total per sublist.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The numbers (an empty item, null or blank text, is an error here, so positions stay aligned).

Outputs

Output	Type	What it gives
totals	number[]	A list as long as the input: each item is the sum of everything up to and including it.

Tags: running accumulate progress s-curve

List.Duplicates

The values that occur more than once, with how many times each occurs — duplicate GUIDs, marks or names. Values compare as in List.CountValues (text with its case); nulls are not duplicates.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The values to check.

Outputs

Output	Type
duplicates	any
counts	integer[]

Returns: The repeated values (first appearance order) and how many times each occurs.

Tags: duplicate repeated twice unique check audit

List.Histogram

Splits the range of the numbers into equal bins and counts how many fall in each — the data behind a distribution chart. Nulls and blank text are skipped; with no numbers at all the four lists are empty and the node shows a warning instead of an error.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The numbers (nulls and blank text are skipped).
bins	integer	10	How many bins, from the smallest to the largest value.

Outputs

Output	Type
lower	number[]
upper	number[]
counts	integer[]
labels	string[]

Returns: For each bin: its lower edge, upper edge, count and a text label; empty lists (with a warning) when there are no numbers.

Tags: distribution bins buckets chart frequency range

List.Median

The middle value of the numbers of a list (the mean of the two middle ones when the count is even); the same as List.Percentile at 50. Nulls and blank text are skipped; with no numbers at all the result is empty and the node shows a warning instead of an error.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The numbers (nulls and blank text are skipped).

Outputs

Output	Type	What it gives
median	number	The median (the mean of the two middle values when the count is even); empty (with a warning) when the list has no numbers.

Tags: middle aggregate typical

List.MostCommon

The value that occurs most often in a list (the earliest wins a tie) and how many times. Values compare as in List.CountValues (text with its case); nulls are not counted. A list with nothing but nulls is an error.

Inputs

Input	Type	Default	What it does
list required	any[]	—	The values to check (at least one non-null).

Outputs

Output	Type
item	any
count	integer

Returns: The most common value (the first to appear wins a tie) and how many times it occurs.

Tags: mode frequent popular typical

List.Percentile

The value below which a given percentage of the numbers lie (linear interpolation, like Excel's PERCENTILE.INC); 50 is the median, 0 the smallest and 100 the largest number. Nulls and blank text are skipped; with no numbers at all the result is empty and the node shows a warning instead of an error.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The numbers (nulls and blank text are skipped).
percent	number	90	Which percentile, 0 to 100 (50 is the median, 90 the value 90 % of the list lies below).

Outputs

Output	Type	What it gives
value	number	The value at that percentile, interpolated linearly (like Excel's PERCENTILE.INC); empty (with a warning) when the list has no numbers.

Tags: quantile quartile aggregate percent median

List.Product

Multiplies the numbers of a list. Nulls and blank text are skipped and an empty list gives 1. A list inside the list is an error: set the input to @L2 for one product per sublist.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The numbers (nulls and blank text are skipped).

Outputs

Output	Type	What it gives
product	number	The product; 1 for an empty list.

Tags: multiply aggregate times

List.StandardDeviation

The standard deviation of the numbers of a list (population by default; tick 'sample' to divide by n-1, which needs at least two numbers). Nulls and blank text are skipped; with too few numbers the result is empty and the node shows a warning instead of an error.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The numbers (nulls and blank text are skipped); two are needed for a sample.
sample	boolean	false	True divides by n-1 (a sample of a larger population); false (default) divides by n.

Outputs

Output	Type	What it gives
standardDeviation	number	The standard deviation; empty (with a warning) when there are not enough numbers.

Tags: spread variance deviation stdev statistics

List.Statistics

Count, sum, minimum, maximum, average, median and standard deviation of a list of numbers in one node. Nulls and blank text are skipped and not counted; with no numbers at all the count is 0, the sum is 0, the rest is empty and the node shows a warning. Text that reads as a number is compared as a number here (List.MaximumItem compares text as text).

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The numbers (nulls and blank text are skipped).

Outputs

Output	Type
count	integer
sum	number
min	number
max	number
average	number
median	number
standardDeviation	number

Returns: count, sum, min, max, average, median and standardDeviation; everything but count and sum is empty for no numbers.

Tags: summary describe aggregate kpi qto min max statistics

List.Sum

Adds up the numbers of a list. Nulls and blank text (an empty cell) are skipped, text such as "12.5" is read as a number, and an empty list gives 0. A list inside the list is an error: set the input to @L2 for one total per sublist.

Inputs

Input	Type	Default	What it does
list any number of wires required	any[]	—	The numbers (nulls and blank text are skipped; text such as "12.5" is read as a number).

Outputs

Output	Type	What it gives
sum	number	The total; 0 for an empty list.

Tags: total add aggregate quantity qto sum