✅ query > Global helpers > exportGlobals > should attach $, $$, and Query to the global scope
✅ query > Global helpers > exportGlobals > should allow selective global exports
✅ query > Global helpers > restoreGlobals > should restore the original values of $ and $$
✅ query > Global helpers > restoreGlobals > should remove Query from the global scope when specified
✅ query > Global helpers > useAlias > should create a new Query instance with the provided arguments
✅ query > selectors > query should query DOM when given a selector
✅ query > selectors > query should allow DOM elements to be passed in
✅ query > selectors > query should allow an array of elements to be passed in
✅ query > selectors > query should allow a NodeList to be passed in
✅ query > selectors > should accept a NodeList as a selector
✅ query > selectors > should accept a DocumentFragment as a selector
✅ query > selectors > should accept a custom element as a selector
✅ query > selectors > should create an element from an HTML string
✅ query > selectors > should create an element from an HTML string with attributes
✅ query > selectors > should create multiple elements from an HTML string
✅ query > selectors > should handle mixed content in HTML string
✅ query > find > find should return all nested elements inside an element
✅ query > find > find should return all nested elements inside multiple elements
✅ query > siblings > siblings should return all siblings of an element
✅ query > siblings > siblings should return all siblings matching a selector
✅ query > is > is should return true if all elements match a selector
✅ query > is > is should return false if not all elements match a selector
✅ query > index > index should return -1 if no matching element is found among its siblings
✅ query > index > index should return the first matching index
✅ query > index > index should return the indexes of multiple element among its siblings
✅ query > index > index should return the index of the first element when no argument is passed
✅ query > index > index should return -1 when the element is not found within the collection
✅ query > index > index should return -1 when the selector does not match any elements
✅ query > indexOf > index should return the index of an element among its siblings matching a selector
✅ query > indexOf > index should return the index of the element within the collection when a DOM element is passed
✅ query > indexOf > index should return the index of the element within the collection when a Query object is passed
✅ query > not > not should filter out elements that match a selector
✅ query > closest > closest should return the closest parent matching a selector
✅ query > closest > closest should not return a parent if it does not match a selector
✅ query > closestDeep > should return the closest ancestor matching a selector
✅ query > closestDeep > should return the closest ancestor matching a DOM element
✅ query > closestDeep > should return an empty Query instance if no matching ancestor is found
✅ query > filter > filter should return elements that match a selector
✅ query > filter > filter should return elements that match a function
✅ query > children > children should return all children of an element
✅ query > children > children should return all children matching a selector
✅ query > children > children return an array of children when iterating over multiple elements
✅ query > parent > parent should return the parent of an element
✅ query > parent > parent should return the parent of an element matching a selector
✅ query > parent > parent should not return a parent if it does not match a selector
✅ query > dispatchEvent > should dispatch custom events with different event options
✅ query > dispatchEvent > should dispatch events on multiple elements
✅ query > on > should attach an event handler to elements
✅ query > on > should attach an event handler to multiple elements
✅ query > on > should attach multiple event handlers to elements
✅ query > on > should return an array of event handlers when multiple attached
✅ query > on > should return a single event handler when only one attached
✅ query > on > should be able to remove event handlers using custom abortController
✅ query > on > should be able to remove event handlers using returned abortController
✅ query > on > should be able to use event delegation
✅ query > on > should be able to pass in custom abortController
✅ query > on > should have delegated set on return object is delegated
✅ query > on > should have delegated not set on return object is delegated
✅ query > on > should return the native event on return object eventListener
✅ query > on > should attach multiple event handlers when passing space-separated events
✅ query > on > should handle multiple events with delegation
✅ query > on > should handle multiple events with options
✅ query > on > should handle multiple events with delegation and options
✅ query > on > should handle empty spaces in event string
✅ query > on > should return handlers for all events when returnHandler is true
✅ query > on > should properly remove specific events using off()
✅ query > one > one should attach a one-time event handler to elements
✅ query > one > should handle multiple space-separated events and remove all handlers after any one fires
✅ query > one > should handle multiple events with delegation
✅ query > one > should handle three or more space-separated events
✅ query > one > should group one handlers not calling others in group
✅ query > one > should remove handlers based on grouping
✅ query > one > should handle nested events correctly
✅ query > one > should work with dynamically added elements
✅ query > off > should remove a given event type
✅ query > off > should remove an array of event names
✅ query > off > should remove a specific event handler
✅ query > off > should allow native removeEventListener use with handler
✅ query > off > should remove delegated events
✅ query > off > should remove passed event objects
✅ query > trigger > should trigger a custom event on elements
✅ query > trigger > should trigger a custom event with extra parameters
✅ query > trigger > should trigger events on multiple elements
✅ query > click > should trigger a click event on elements
✅ query > click > should trigger a click event with extra parameters
✅ query > click > should trigger click events on multiple elements
✅ query > remove > remove should remove an element
✅ query > remove > remove should remove multiple elements that match selector
✅ query > add class > add class should add a class
✅ query > add class > add class should allow multiple classes to be added
✅ query > add class > add class should add multiple classes to multiple elements
✅ query > has class > has class should return true if an element has a class
✅ query > has class > has class should not return true if an element does not have a class
✅ query > remove class > remove class should remove a single class
✅ query > remove class > remove class should remove multiple classes
✅ query > html > html should return the innerHTML of an element
✅ query > html > html should set the innerHTML of an element
✅ query > outerHTML > outerHTML should return the outerHTML of an element
✅ query > outerHTML > outerHTML should set the outerHTML of an element
✅ query > text > text should return the textContent of an element
✅ query > text > text should return the text including all children recursively
✅ query > text > text should remove whitespace for recursive text
✅ query > text > text should set textcontent for multiple elements
✅ query > value > value should return the value of an input
✅ query > value > value should set the value of an input
✅ query > value > value should return the value of a select
✅ query > value > value should set the value of a select
✅ query > value > value should set the value of a textarea
✅ query > value > value should return the value of a textarea
✅ query > value > value should ignore setting value on non form elements
✅ query > value > value should ignore getting value on non form elements
✅ query > value > val should be an alias of value
✅ query > attr > should set and get boolean attributes
✅ query > attr > should set and get custom data attributes
✅ query > prop > should set and get properties on elements other than form elements
✅ query > css > css should set a style property
✅ query > css > css should set multiple style properties
✅ query > css > css should get a style property
✅ query > css > css should return an array of style properties when multiple elements
✅ query > css > should handle camelCase and kebab-case property names
✅ query > css > should return computed styles when requested
✅ query > attr > attr should set an attribute
✅ query > attr > attr should set multiple attributes
✅ query > attr > attr should get an attribute
✅ query > attr > attr should get attribute from multiple elements
✅ query > attr > should handle properties that are not reflected as attributes
✅ query > removeAttr > removeAttr should remove an attribute
✅ query > removeAttr > removeAttr should remove an attribute from multiple elements
✅ query > each > each should iterate over each element passing index
✅ query > get > get should return an element at an index
✅ query > get > get should return an array of elements when no index
✅ query > eq > eq should return an element at an index
✅ query > textNode > textNode should return only immediate text and not child el text
✅ query > focus > focus should focus an element
✅ query > blur > blur should blur an element
✅ query > clone > should create a deep clone of the elements in the Query instance
✅ query > Insertion Methods > prepend > should prepend content to the target
✅ query > Insertion Methods > prepend > should prepend multiple content items to the target
✅ query > Insertion Methods > append > should append content to the target
✅ query > Insertion Methods > append > should append multiple content items to the target
✅ query > Insertion Methods > insertBefore > should insert elements before the target
✅ query > Insertion Methods > insertAfter > should insert elements after the target
✅ query > Insertion Methods > insertAfter > should insert elements after each target element
✅ query > next > should return the next sibling element
✅ query > next > should return the next sibling element matching a selector
✅ query > next > should return an empty Query instance if no matching next sibling is found
✅ query > prev > should return the previous sibling element
✅ query > prev > should return the previous sibling element matching a selector
✅ query > prev > should return an empty Query instance if no matching previous sibling is found
✅ query > Value-returning methods > attr > should return undefined when getting attribute on non-existent element
✅ query > Value-returning methods > prop > should return undefined when getting property on non-existent element
✅ query > Value-returning methods > css > should return undefined when getting style on non-existent element
✅ query > Value-returning methods > html > should return undefined when getting HTML on non-existent element
✅ query > Value-returning methods > text > should return undefined when getting text on non-existent element
✅ query > Value-returning methods > val > should return undefined when getting value on non-existent element
✅ query > Value-returning methods > height > should return undefined when getting height on non-existent element
✅ query > Value-returning methods > width > should return undefined when getting width on non-existent element
✅ query > Value-returning methods > scrollHeight > should return undefined when getting scrollHeight on non-existent element
✅ query > Value-returning methods > scrollWidth > should return undefined when getting scrollWidth on non-existent element
✅ query > Value-returning methods > scrollLeft > should return undefined when getting scrollLeft on non-existent element
✅ query > Value-returning methods > scrollTop > should return undefined when getting scrollTop on non-existent element
✅ query > end > should return to the previous selection after a traversal method
✅ query > end > should return the same Query instance if there is no previous selection
✅ query > end > should allow chaining back up multiple levels
✅ query > end > should work with multiple chain traversal methods in between
✅ query > end > should match the example from documentation
✅ query > end > should handle complex nested chains with multiple end() calls

✅ Reaction > Basic Usage > should trigger reaction on reactive value change
✅ Reaction > Basic Usage > should handle firstRun and stop computation
✅ Reaction > Equality > should not re-run for identical objects with isEqual
✅ Reaction > Equality > should always re-run when custom isEqual returns false
✅ Reaction > Controlling Reactivity > guard should control reactivity
✅ Reaction > Controlling Reactivity > guard should control reactivity - example 2
✅ Reaction > Controlling Reactivity > guard should not re-run for identical objects
✅ Reaction > Controlling Reactivity > peek should not establish reactive dependency
✅ Reaction > Controlling Reactivity > nonreactive should prevent reactive updates within its scope
✅ Reaction > Controlling Reactivity > flush should process updates immediately
✅ Reaction > Flushing > afterFlush should call registered callbacks after flushing
✅ Reaction > Flushing > afterFlush should call multiple registered callbacks after flushing
✅ Reaction > Helper Functions > should correctly manipulate array with helpers
✅ Reaction > Debugging > Reaction should track current context for debugging
✅ Reaction > Debugging > Reaction should track current stack trace with getSource

✅ Signal > Initialization > provide value
✅ Signal > Initialization > provide get and set helper
✅ Signal > Initialization > should update and return the new value correctly
✅ Signal > Equality > allow custom equality
✅ Signal > Equality > identical objects shouldnt trigger reactivity
✅ Signal > Equality > identical objects with different key order shouldnt trigger reactivity
✅ Signal > Reactivity > should notify subscribers on value change
✅ Signal > Reactivity > Peek should not trigger reactivity
✅ Signal > Reactivity > Reactive variables should trigger nested dependencies
✅ Signal > Array Utilities > Push should handle multiple values
✅ Signal > Array Utilities > Unshift should handle multiple values
✅ Signal > Array Utilities > Splice should remove and insert elements
✅ Signal > Array Utilities > Splice should handle multiple inserts
✅ Signal > Array Utilities > Splice should handle deletion without insertion
✅ Signal > Array Utilities > Splice should trigger reactions when modified
✅ Signal > Array Utilities > setIndex should change value at index
✅ Signal > Array Utilities > removeIndex should remove value at index
✅ Signal > Array Utilities > setArrayProperty should set an object property at index
✅ Signal > Array Utilities > setArrayProperty should set all object properties when no index specified
✅ Signal > Transformation Helpers > map should transform each item in the array
✅ Signal > Transformation Helpers > map should trigger reactions
✅ Signal > Transformation Helpers > filter should remove items based on predicate
✅ Signal > Transformation Helpers > filter should trigger reactions
✅ Signal > Transformation Helpers > filter should handle complex objects
✅ Signal > Transformation Helpers > map should handle complex transformations
✅ Signal > Boolean Helpers > toggle should toggle a boolean
✅ Signal > Mutation Utilities > map should apply a transformation to each item
✅ Signal > Mutation Utilities > filter should remove items based on a filter
✅ Signal > ID Utilities > getID should get id from an item
✅ Signal > ID Utilities > getIDs should get all ids from an item
✅ Signal > ID Utilities > hasID should match an item ID
✅ Signal > ID Helpers > setProperty should set the property of the item matching an id
✅ Signal > ID Helpers > getItem should get the item with matching id
✅ Signal > ID Helpers > replaceItem should replace an item matching an ID
✅ Signal > ID Helpers > removeItem should remove an item matching an ID
✅ Signal > ID Helpers > setProperty should set the property of the item matching a given id
✅ Signal > ID Helpers > setArrayProperty should set an object property at index
✅ Signal > ID Helpers > setArrayProperty should set all object properties when no index specified
✅ Signal > Cloning Behavior with Signals > should maintain reactivity when using a Signal inside another Signal
✅ Signal > Cloning Behavior with Signals > should not retrigger reactivity on array when updating objects

✅ @semantic-ui/tailwinds > collectContent > should extract content from component definition
✅ @semantic-ui/tailwinds > collectContent > should handle subTemplates
✅ @semantic-ui/tailwinds > collectContent > should return empty strings when no content
✅ @semantic-ui/tailwinds > TailwindPlugin > should return unchanged definition when no content
✅ @semantic-ui/tailwinds > TailwindPlugin > should be an async function

✅ TemplateCompiler > should compile a template
✅ TemplateCompiler > expressions > should compile basic expressions
✅ TemplateCompiler > expressions > should compile html expressions with triple brackets
✅ TemplateCompiler > expressions > should preserve boolean values
✅ TemplateCompiler > conditionals > should compile a template with an if conditional
✅ TemplateCompiler > conditionals > should preserve boolean values in conditionals
✅ TemplateCompiler > conditionals > should preserve numerical values
✅ TemplateCompiler > conditionals > should preserve string values in conditionals
✅ TemplateCompiler > conditionals > should handle elseif conditionals
✅ TemplateCompiler > conditionals > should support multiple elseif conditonals
✅ TemplateCompiler > conditionals > should support nested conditionals in else if
✅ TemplateCompiler > conditionals > should handle else conditionals
✅ TemplateCompiler > conditionals > should handle nested conditionals with 2 levels
✅ TemplateCompiler > conditionals > should handle nested conditionals with 3 levels
✅ TemplateCompiler > nested expressions > should handle single level of nesting in expressions
✅ TemplateCompiler > nested expressions > should handle multiple levels of nesting in expressions
✅ TemplateCompiler > nested expressions > should handle nested method calls with object parameters
✅ TemplateCompiler > nested expressions > should handle mixed bracket types in nested expressions
✅ TemplateCompiler > nested expressions > should handle deeply nested conditional expressions
✅ TemplateCompiler > nested expressions > should handle nested array expressions with objects
✅ TemplateCompiler > nested expressions > should handle nested expressions in boolean attributes
✅ TemplateCompiler > each loops > should compile a template with an each loop
✅ TemplateCompiler > each loops > should compile a template with an each_as syntax
✅ TemplateCompiler > each loops > should compile a template with an each_as syntax with index
✅ TemplateCompiler > each loops > should compile a template with an each_as syntax with else condition
✅ TemplateCompiler > each loops > should compile a template with an each-in loop syntax
✅ TemplateCompiler > each loops > should compile a template with an each-as loop syntax
✅ TemplateCompiler > each loops > should compile a template with an each-as loop syntax with index
✅ TemplateCompiler > each loops > should compile a template with an each-as loop syntax with else condition
✅ TemplateCompiler > each loops > should compile a template with custom item and index names using comma syntax
✅ TemplateCompiler > each loops > should handle expressions within the comma syntax
✅ TemplateCompiler > each loops > should handle expressions in both item and index positions
✅ TemplateCompiler > each loops > should handle various whitespace patterns in the each syntax
✅ TemplateCompiler > each loops > should work with else blocks when using custom item and index names
✅ TemplateCompiler > each loops > should compile a template with an if condition inside an each loop
✅ TemplateCompiler > each loops > should compile a template with an each loop with an else condition
✅ TemplateCompiler > each loops > should compile a template with a nested each loop with else conditions
✅ TemplateCompiler > each loops > should verify that if/else and each/else conditions can work independently
✅ TemplateCompiler > each loops > should handle complex nested conditions with multiple levels of if/each/else
✅ TemplateCompiler > each loops > should verify that multiple else-if can work correctly after if blocks
✅ TemplateCompiler > template partials > should compile a template with a partial
✅ TemplateCompiler > template partials > should compile a template with a partial and data
✅ TemplateCompiler > template partials > should compile a template with a partial and reactive data
✅ TemplateCompiler > template partials > should compile a template with a partial and data containing parentheses
✅ TemplateCompiler > template partials > should compile a template with a partial and data containing parentheses and spaces
✅ TemplateCompiler > template partials > should compile a template with a partial and data containing line breaks
✅ TemplateCompiler > template partials > should compile a template with a partial and data containing multiple parentheses
✅ TemplateCompiler > slots > should compile a template with a slot
✅ TemplateCompiler > boolean attributes > should correctly identify known boolean attributes like checked
✅ TemplateCompiler > boolean attributes > should correctly identify known boolean attributes even if quoted
✅ TemplateCompiler > boolean attributes > should identify boolean attributes when no quotes
✅ TemplateCompiler > boolean attributes > should identify not boolean attributes when no quotes
✅ TemplateCompiler > error conditions > should throw an error when an else included outside an if
✅ TemplateCompiler > error conditions > should throw an error when an elseif included outside an if
✅ TemplateCompiler > error conditions > should throw an error when closing if tag is included without an if

✅ StringScanner > should let you consume a regex
✅ StringScanner > should let you consume a string
✅ StringScanner > should return the rest of a string with rest
✅ StringScanner > should consume until a given string
✅ StringScanner > should permit peeking at a character
✅ StringScanner > should let you returnTo the first previous instance of pattern
✅ StringScanner > should let you log errors with fatal
✅ StringScanner > should let you check if the scanner is at the end of the input
✅ StringScanner > get context > getContext should return attribute and tag info inside tag
✅ StringScanner > get context > getContext should return booleanAttribute when unquoted attribute
✅ StringScanner > get context > getContext should return booleanAttribute when a boolean attribute type
✅ StringScanner > get context > getContext should return inside tag false when outside tagz

✅ clone > should clone dom nodes
✅ copyText > should call navigator.clipboard.writeText with the provided text
✅ getText > should fetch the text content from the provided source
✅ isDOM > should return true for Element instances
✅ isDOM > should return true for Document instances
✅ isDOM > should return true for window
✅ isDOM > should return true for DocumentFragment instances

✅ Array Utilities > unique should remove duplicates
✅ Array Utilities > filterEmpty should remove falsey values
✅ Array Utilities > last should return the last n elements
✅ Array Utilities > firstMatch should return the first matching element based on callback
✅ Array Utilities > findIndex should return the index of the first matching element
✅ Array Utilities > remove should remove elements based on a callback or value
✅ Array Utilities > inArray should check if a value is in the array
✅ Array Utilities > range should create an array of numbers
✅ Array Utilities > where > should filter an array of objects based on properties
✅ Array Utilities > flatten > should flatten a nested array
✅ Array Utilities > flatten > should return the original array if it is not nested
✅ Array Utilities > some > should return true if at least one element matches the predicate
✅ Array Utilities > some > should return false if no elements match the predicate
✅ Array Utilities > some > should return false for an empty array
✅ Array Utilities > isEmpty > should return true for null or undefined
✅ Array Utilities > isEmpty > should return true for empty arrays
✅ Array Utilities > isEmpty > should return true for empty objects
✅ Array Utilities > isEmpty > should return false for non-empty arrays
✅ Array Utilities > isEmpty > should return true if all keys are undefined
✅ Array Utilities > isEmpty > should return false for non-empty objects
✅ Number Utilities > roundNumber > should round numbers to the specified number of significant digits
✅ Number Utilities > roundNumber > should handle negative numbers correctly
✅ Number Utilities > roundNumber > should return the original number if it is not a finite number
✅ Number Utilities > roundNumber > should return the number unchanged if digits is not a positive integer
✅ Number Utilities > roundNumber > should return the original number if it is not a number
✅ Number Utilities > roundNumber > should handle very large and very small numbers correctly
✅ Number Utilities > sum > should return the sum of an array of numbers
✅ Number Utilities > sum > should return 0 for an empty array
✅ Browser Utilities > getKeyFromEvent > should return an empty string if the event.key is not defined
✅ Browser Utilities > getKeyFromEvent > should return an empty string if the event has no key property
✅ Browser Utilities > getKeyFromEvent > should return the lowercase key for a simple key press
✅ Browser Utilities > getKeyFromEvent > should return the correct key for a special key press
✅ Browser Utilities > getKeyFromEvent > should include the "ctrl" modifier when the ctrlKey is pressed
✅ Browser Utilities > getKeyFromEvent > should include the "alt" modifier when the altKey is pressed
✅ Browser Utilities > getKeyFromEvent > should include the "shift" modifier when the shiftKey is pressed
✅ Browser Utilities > getKeyFromEvent > should include the "meta" modifier when the metaKey is pressed
✅ Browser Utilities > getKeyFromEvent > should include multiple modifiers when multiple modifier keys are pressed
✅ Browser Utilities > getKeyFromEvent > should return the correct key for the space key
✅ Browser Utilities > isServer > should return true if window is undefined
✅ Browser Utilities > isClient > should return false if window is undefined
✅ Type Checking Utilities > isObject should correctly identify objects
✅ Type Checking Utilities > isPlainObject should only identify plain objects
✅ Type Checking Utilities > isString should correctly identify strings
✅ Type Checking Utilities > isNumber should correctly identify numbers
✅ Type Checking Utilities > isArray should correctly identify arrays
✅ Type Checking Utilities > isBinary should correctly identify binary objects
✅ Type Checking Utilities > isFunction should correctly identify functions
✅ Type Checking Utilities > isPromise should correctly identify promises
✅ Type Checking Utilities > isArguments should correctly identify arguments objects
✅ Type Checking Utilities > isClassInstance > should return true for a custom class instance
✅ Type Checking Utilities > isClassInstance > should return false for a plain object
✅ Type Checking Utilities > isClassInstance > should return false for primitive values
✅ Type Checking Utilities > isClassInstance > should return false for an array
✅ Type Checking Utilities > isClassInstance > should return false for a Date object
✅ Type Checking Utilities > isClassInstance > should return false for a regular expression
✅ Type Checking Utilities > isClassInstance > should return false for a Map object
✅ Type Checking Utilities > isClassInstance > should return false for a Set object
✅ Type Checking Utilities > isClassInstance > should return false for an Error object
✅ Type Checking Utilities > isClassInstance > should return false for a Uint8Array
✅ Type Checking Utilities > isClassInstance > should return false for functions
✅ Type Checking Utilities > groupBy > should group objects by a simple property
✅ Type Checking Utilities > groupBy > should group objects by a nested property
✅ Type Checking Utilities > groupBy > should handle an empty array
✅ Type Checking Utilities > groupBy > should handle objects with missing property
✅ Type Checking Utilities > groupBy > should handle a property that does not exist on any objects
✅ Type Checking Utilities > moveItem > should move item to a specific index when using number
✅ Type Checking Utilities > moveItem > should move item to first position when using "first"
✅ Type Checking Utilities > moveItem > should move item to last position when using "last"
✅ Type Checking Utilities > moveItem > should handle moving item that matches predicate function
✅ Type Checking Utilities > moveItem > should clamp target index to valid array bounds
✅ Type Checking Utilities > moveItem > should return original array if item not found
✅ Type Checking Utilities > moveItem > should not modify array if source and target indices are the same
✅ Type Checking Utilities > moveItem > should handle arrays with single item
✅ Type Checking Utilities > moveToFront > should be equivalent to moveItem with "first"
✅ Type Checking Utilities > moveToFront > should move matching item to front of array
✅ Type Checking Utilities > moveToFront > should handle predicate function
✅ Type Checking Utilities > moveToBack > should be equivalent to moveItem with "last"
✅ Type Checking Utilities > moveToBack > should move matching item to end of array
✅ Type Checking Utilities > moveToBack > should handle predicate function
✅ Type Checking Utilities > intersection > returns common elements between arrays
✅ Type Checking Utilities > intersection > handles arrays with no common elements
✅ Type Checking Utilities > intersection > returns array for single input
✅ Type Checking Utilities > intersection > returns empty array for no input
✅ Type Checking Utilities > intersection > handles arrays with duplicates
✅ Type Checking Utilities > intersection > maintains element order from first array
✅ Type Checking Utilities > difference > returns elements only in first array
✅ Type Checking Utilities > difference > returns first array when no others provided
✅ Type Checking Utilities > difference > returns empty array for no input
✅ Type Checking Utilities > difference > handles arrays with no common elements
✅ Type Checking Utilities > difference > handles arrays with duplicates
✅ Type Checking Utilities > difference > maintains element order
✅ Type Checking Utilities > uniqueItems > returns elements unique to each array
✅ Type Checking Utilities > uniqueItems > returns empty array for single input array
✅ Type Checking Utilities > uniqueItems > returns empty array for no input
✅ Type Checking Utilities > uniqueItems > handles arrays with duplicates
✅ Type Checking Utilities > sortBy > should sort by a simple key
✅ Type Checking Utilities > sortBy > should sort by a nested key
✅ Type Checking Utilities > sortBy > should handle custom comparator
✅ Type Checking Utilities > sortBy > should handle sorting with additional object context in comparator
✅ Type Checking Utilities > sortBy > should return a new array and not mutate the original
✅ Type Checking Utilities > sortBy > should sort objects with undefined values last
✅ Date Utilities > formatDate > should format dates correctly with predefined formats
✅ Date Utilities > formatDate > should format date with default options
✅ Date Utilities > formatDate > should format date with 12-hour format when hour12 is true
✅ Date Utilities > formatDate > should format date with 24-hour format when hour12 is false
✅ Date Utilities > formatDate > should format date with custom timezone
✅ Date Utilities > formatDate > should format date with predefined format (LT)
✅ Date Utilities > formatDate > should format date with predefined format (LTS)
✅ Date Utilities > formatDate > should format date with predefined format (L)
✅ Date Utilities > formatDate > should format date with predefined format (LL)
✅ Date Utilities > formatDate > should format date with predefined format (LLL)
✅ Date Utilities > formatDate > should format date with predefined format (LLLL)
✅ Date Utilities > formatDate > should format date with custom format string
✅ Date Utilities > formatDate > should handle single-digit hours correctly
✅ Date Utilities > formatDate > should handle midnight correctly
✅ Date Utilities > formatDate > should handle noon correctly
✅ Date Utilities > formatDate > should handle leap years correctly
✅ Date Utilities > formatDate > should handle invalid dates gracefully
✅ Object Utilities > keys > keys should return the keys of an object
✅ Object Utilities > values > values should return the values of an object
✅ Object Utilities > mapObject > mapObject should create an object with the same keys and mapped values
✅ Object Utilities > mapObject > should create a new object without mutating the original
✅ Object Utilities > mapObject > should pass both value and key to the callback
✅ Object Utilities > mapObject > should handle empty objects
✅ Object Utilities > mapObject > should handle non-numeric values
✅ Object Utilities > mapObject > should preserve keys while mapping values
✅ Object Utilities > extend > extend should merge properties from source into target, including getters and setters
✅ Object Utilities > pick > pick should create an object composed of the picked properties
✅ Object Utilities > filterObject > should filter an object based on a predicate
✅ Object Utilities > filterObject > should return an empty object if no properties match the predicate
✅ Object Utilities > arrayFromObject > should convert an object to an array of key-value pairs
✅ Object Utilities > arrayFromObject > should return the original array if the input is already an array
✅ Object Utilities > proxyObject > should create a proxy that reflects changes in the source object
✅ Object Utilities > proxyObject > should handle nested properties correctly
✅ Object Utilities > proxyObject > should handle adding new properties to the source object
✅ Object Utilities > proxyObject > should handle deleting properties from the source object
✅ Object Utilities > proxyObject > should not affect the original reference object
✅ Object Utilities > proxyObject > should reflect updates made to the reference object after proxy creation
✅ Object Utilities > get > get should support array like "arr.1.value" notation in lookup
✅ Object Utilities > get > get should access a nested object field from a string
✅ Object Utilities > get > get should support files with "." in the key
✅ Object Utilities > get > get should support deeply nested files with "." in the key
✅ Object Utilities > get > get should return undefined when accessing a non-existent nested key
✅ Object Utilities > get > get should support accessing nested keys with dots and array indexes
✅ Object Utilities > get > get should return undefined when accessing an out-of-bounds array index
✅ Object Utilities > get > get should return undefined when accessing a non-existent array index
✅ Object Utilities > hasProperty > hasProperty should return true if the object has the specified property
✅ Object Utilities > reverseKeys > reverseKeys should reverse a lookup object's keys and values
✅ Object Utilities > reverseKeys > reverseKeys should reverse array values
✅ Object Utilities > onlyKeys > should return an object with only the specified keys
✅ Object Utilities > onlyKeys > should return an empty object if no keys are specified
✅ Object Utilities > any > should be an alias for some
✅ isEqual > Various types > should return true for equal strings
✅ isEqual > Various types > should return true for equal numbers
✅ isEqual > Various types > should return false for different numbers
✅ isEqual > Various types > should return true for equal arrays
✅ isEqual > Various types > should return false for arrays with different order
✅ isEqual > Various types > should return true for equal Sets
✅ isEqual > Various types > should return false for different Sets
✅ isEqual > Various types > should return true for equal Maps
✅ isEqual > Various types > should return true for identical RegExp
✅ isEqual > Various types > should return false for different RegExp flags
✅ isEqual > Various types > should return false for different RegExp
✅ isEqual > Various types > should return false for Maps with different content
✅ isEqual > Various types > should return true for deeply equal objects
✅ isEqual > Various types > should return false for objects with different structure
✅ isEqual > Various types > should return true for equal dates
✅ isEqual > Various types > should return false for different dates
✅ isEqual > Various types > should return true for equal binary data
✅ isEqual > Various types > should return false for different binary data
✅ isEqual > Various types > should return true for the same function reference
✅ isEqual > Various types > should return false for different functions
✅ isEqual > Various types > should return true for complex nested structures
✅ isEqual > Various types > should return false for complex nested structures with differences
✅ isEqual > Various types > should ignore non-enumerable properties by default
✅ isEqual > should return false for == values that arent equal
✅ function utilities > noop should not return anything
✅ function utilities > wrapFunction should return the same function if a function is passed
✅ function utilities > wrapFunction should return a function that returns the passed value if a non-function is passed
✅ function utilities > memoize > should memoize the return value of a function
✅ function utilities > memoize > should memoize different arguments separately
✅ function utilities > memoize > should memoize functions with no arguments
✅ function utilities > memoize > should memoize functions with complex arguments
✅ function utilities > memoize > should preserve the context of the original function
✅ function utilities > memoize > should allow custom hashing function
✅ function utilities > memoize > should handle edge cases with custom hashing
✅ function utilities > debounce > should delay function execution
✅ function utilities > debounce > should only execute once for multiple calls within delay
✅ function utilities > debounce > should accept a number as the second argument for delay
✅ function utilities > debounce > should execute immediately if immediate option is true
✅ function utilities > debounce > should allow to cancel delayed execution
✅ function utilities > debounce > should pass correct arguments to the debounced function
✅ function utilities > debounce > should maintain correct context
✅ String Utilities > should correctly convert kebab-case to camelCase
✅ String Utilities > should correctly convert camelCase to kebab-case
✅ String Utilities > should capitalize the first letter of each word
✅ String Utilities > should convert a string to title case
✅ String Utilities > joinWords > should join words with default settings
✅ String Utilities > joinWords > should handle an empty array
✅ String Utilities > joinWords > should handle a single word
✅ String Utilities > joinWords > should handle two words
✅ String Utilities > joinWords > should use custom separator
✅ String Utilities > joinWords > should use custom last separator
✅ String Utilities > joinWords > should not use Oxford comma when specified
✅ String Utilities > joinWords > should add quotes when specified
✅ String Utilities > joinWords > should apply transform function when provided
✅ String Utilities > joinWords > should handle complex configuration
✅ String Utilities > joinWords > should handle non-array input
✅ String Utilities > joinWords > should handle array with falsy values
✅ ID/Hashing Functions > tokenize > should convert a string to a token
✅ ID/Hashing Functions > prettifyID > should return "0" for input 0
✅ ID/Hashing Functions > prettifyID > should convert a number to base 36 representation
✅ ID/Hashing Functions > prettifyID > should handle large numbers correctly
✅ ID/Hashing Functions > hashCode > should produce consistent hash code for the same input
✅ ID/Hashing Functions > hashCode > should generally produce unique hash codes for different inputs
✅ ID/Hashing Functions > hashCode > should hash objects
✅ ID/Hashing Functions > hashCode > should hash dates
✅ ID/Hashing Functions > hashCode > should hash numbers
✅ ID/Hashing Functions > hashCode > should produce different hash codes for similar inputs
✅ ID/Hashing Functions > hashCode > should handle extremely long inputs
✅ ID/Hashing Functions > hashCode > should handle inputs with special characters
✅ ID/Hashing Functions > hashCode > should handle inputs with Unicode characters
✅ ID/Hashing Functions > hashCode > should handle inputs with emojis
✅ ID/Hashing Functions > hashCode > should handle inputs with control characters
✅ ID/Hashing Functions > hashCode > should handle empty input
✅ ID/Hashing Functions > hashCode > should handle null input
✅ ID/Hashing Functions > hashCode > should handle undefined input
✅ ID/Hashing Functions > hashCode > should handle input with leading/trailing whitespace
✅ ID/Hashing Functions > hashCode > should handle input with large integers
✅ ID/Hashing Functions > hashCode > should handle input with small integers
✅ ID/Hashing Functions > hashCode > should handle input with floating-point numbers
✅ ID/Hashing Functions > hashCode > should handle input with Infinity
✅ ID/Hashing Functions > hashCode > should handle input with -Infinity
✅ ID/Hashing Functions > hashCode > should handle input with NaN
✅ ID/Hashing Functions > hashCode > should handle deeply nested objects
✅ ID/Hashing Functions > generateID > should generate a non-empty string
✅ ID/Hashing Functions > generateID > generated IDs should be unique
✅ clone > should clone dates
✅ clone > should return the input value if it is not an object or a function
✅ clone > should deeply clone an array
✅ clone > should clone sets
✅ clone > should clone RegExp objects
✅ clone > should clone maps
✅ clone > should clone deep objects
✅ clone > should handle circular dependencies
✅ regular expression utilities > escapeRegExp > should escape characters that have special meaning in regex
✅ regular expression utilities > escapeHTML > should escape only HTML tag characters
✅ regular expression utilities > escapeHTML > should not modify a string without special characters
✅ Color Utilities > oklchToRgb > should convert basic OKLCH colors to RGB
✅ Color Utilities > oklchToRgb > should convert specific OKLCH colors to RGB (approximate)
✅ Color Utilities > oklchToRgb > should handle different formatting (spaces, commas)
✅ Color Utilities > oklchToRgb > should return null for invalid input strings
✅ Color Utilities > oklchToRgb > should handle edge cases for lightness
✅ Color Utilities > oklchToHex > should convert basic OKLCH colors to Hex
✅ Color Utilities > oklchToHex > should convert specific OKLCH colors to Hex (approximate)
✅ Color Utilities > oklchToHex > should handle different formatting (spaces, commas)
✅ Color Utilities > oklchToHex > should return empty string for invalid input strings
✅ Color Utilities > oklchToHex > should handle edge cases for lightness
✅ Color Utilities > oklchToHex > should handle hex values needing padding
✅ Color Utilities > oklchToHex > should return input string if it is already a valid hex code
✅ Color Utilities > oklchToHex > should return empty string for invalid hex codes if not oklch
✅ Color Utilities > oklchToHex > should return empty string for empty input
✅ iterators > each > Array iteration > should iterate over all elements
✅ iterators > each > Array iteration > should break early if the callback returns false
✅ iterators > each > Object iteration > should iterate over all properties
✅ iterators > each > Object iteration > should break early if the callback returns false
✅ iterators > each > Object iteration > should not iterate over non-enumerable properties
✅ iterators > each > should handle null/undefined gracefully
✅ iterators > asyncEach > should iterate over an array asynchronously
✅ iterators > asyncEach > should handle null/undefined gracefully
✅ iterators > asyncMap > should map an array asynchronously
✅ iterators > asyncMap > should map an object asynchronously
✅ iterators > asyncMap > should handle null/undefined gracefully