[{"_1":2,"_176":-5,"_177":-5},"loaderData",{"_3":4,"_93":94},"root",{"_5":6,"_36":37,"_66":67},"ctx",{"_7":8,"_23":-5,"_24":25,"_26":27,"_28":20,"_29":20,"_30":20,"_31":-5,"_32":33,"_34":20,"_35":20},"auth",{"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20,"_21":22},"sessionClaims","sessionId","sessionStatus","userId","actor","orgId","orgRole","orgSlug","orgPermissions","factorVerificationAge","isAuthenticated",false,"tokenType","session_token","user","preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesChatPanelState","notificationCount",0,"flagDenols","isTeamOrgMember","ENV",{"_38":39,"_40":41,"_42":43,"_44":45,"_46":47,"_48":49,"_50":51,"_52":53,"_54":55,"_56":57,"_58":59,"_60":61,"_62":63,"_64":65},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","VAL_RUNTIME_NAME","prod","RENDER_GIT_COMMIT","6050acf0705e6826bb1b68e27572c5b8979c5bd9","RENDER_GIT_BRANCH","main","CLERK_PUBLISHABLE_KEY","pk_live_Y2xlcmsudmFsLnRvd24k","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","API_URL","https://api.val.town","clerkState",{"_68":69},"__internal_clerk_state",{"_70":71,"_72":47,"_73":74,"_75":74,"_76":20,"_77":74,"_78":74,"_79":74,"_80":74,"_81":82,"_91":20,"_92":20},"__clerk_ssr_state",{"_21":22,"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20},"__publishableKey","__proxyUrl","","__domain","__isSatellite","__signInUrl","__signUpUrl","__afterSignInUrl","__afterSignUpUrl","__clerk_debug",{"_83":20,"_19":20,"_84":74,"_85":86,"_87":74,"_88":47,"_89":20,"_90":74},"isSignedIn","proxyUrl","reason","session-token-and-uat-missing","message","publishableKey","isSatellite","domain","__telemetryDisabled","__telemetryDebug","routes/embed.x.$handle.$name.$",{"_95":96,"_97":98,"_99":100,"_101":102,"_153":154,"_173":174,"_175":-5},"handle","ziggyware","name","CodeUtilities","path","System.Collections.Generic9.ts","project",{"_103":104,"_97":98,"_105":106,"_107":-5,"_108":20,"_109":110,"_111":-5,"_112":-5,"_12":113,"_114":-5,"_115":20,"_116":-5,"_117":-5,"_118":33,"_14":119,"_120":-5,"_121":-5,"_122":123,"_124":123,"_125":126,"_127":126,"_128":126,"_129":123,"_130":123,"_23":131,"_134":135,"_139":140,"_152":20},"id","06febd26-f8ea-11f0-a7ae-42dde27851f2","createdAt",["D",1769234447182],"deletedAt","legacyEnvVars","privacy","public","description","imageUrl","2c6d46b0-54dd-11f0-a86c-6fbc2b29331a","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount","850db142-aa5e-4914-bceb-1e2e085ae4c5","tursoName","tursoHostname","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm",{"_95":96,"_132":133},"profileImageUrl","https://img.clerk.com/eyJ0eXBlIjoicHJveHkiLCJzcmMiOiJodHRwczovL2ltYWdlcy5jbGVyay5kZXYvb2F1dGhfZ2l0aHViL2ltZ18yekJHRDE5SGVoUHUzUENQaXY2MTRkT3h0cncifQ","org",{"_95":96,"_136":133,"_12":113,"_137":138},"avatar","tier","free","branch",{"_141":142,"_97":45,"_103":143,"_144":104,"_145":-5,"_146":-5,"_147":-5,"_148":-5,"_149":-5,"_150":98,"_151":96},"version",343,"06ffcbbc-f8ea-11f0-a7ae-42dde27851f2","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","isOwned","file",{"_103":155,"_97":100,"_156":157,"_158":-5,"_159":143,"_160":161,"_162":163,"_105":164,"_141":165,"_166":167,"_168":169,"_170":20,"_171":-5,"_99":172},"4eff0fe2-ff1e-11f0-9b5c-42dde27851f2","fileId","db444dfc-fe36-11f0-975e-42dde27851f2","parentId","branchId","branchVersion",163,"latest",true,["D",1769916608778],26,"fileType","script","content","/**\n * SYSTEM.COLLECTIONS.GENERIC v3.1 - FIXED & SYNCED\n */\n\nexport class KeyValuePair {\n constructor(public readonly Key: TKey, public readonly Value: TValue) {}\n}\n\nexport class Enumerable implements Iterable {\n protected _items: T[];\n\n constructor(items?: T[] | Iterable | Enumerable) {\n if (items instanceof Enumerable) {\n this._items = [...items.ToArray()];\n } else {\n this._items = Array.from(items || []);\n }\n }\n\n public get Count(): number {\n return this._items.length;\n }\n\n public Where(predicate: (item: T, index: number) => boolean): Enumerable {\n return new Enumerable(this._items.filter((x, i) => predicate(x, i)));\n }\n\n public Select(selector: (item: T, index: number) => TResult): Enumerable {\n return new Enumerable(this._items.map((x, i) => selector(x, i)));\n }\n\n public FirstOrDefault(predicate: (item: T, index: number) => boolean = () => true): T | null {\n return this._items.find((x, i) => predicate(x, i)) ?? null;\n }\n\n public Any(predicate: (item: T, index: number) => boolean = () => true): boolean {\n return this._items.some((x, i) => predicate(x, i));\n }\n\n public All(predicate: (item: T, index: number) => boolean): boolean {\n return this._items.every((x, i) => predicate(x, i));\n }\n\n\n public OrderBy(selector: (item: T) => T): Enumerable {\n return new Enumerable([...this._items].sort((a, b) => selector(a) > selector(b) ? 1 : -1));\n }\n\n public OrderByDescending(selector: (item: T) => T): Enumerable {\n return new Enumerable([...this._items].sort((a, b) => selector(a) > selector(b) ? -1 : 1));\n }\n\n public ToArray(): T[] { return Array.from(this._items); }\n public ToList(): List { return new List(this._items); }\n\n public [Symbol.iterator](): Iterator { return this._items[Symbol.iterator](); }\n}\n\nexport class Dictionary extends Enumerable> {\n private _map = new Map();\n\n public Add(key: TKey, value: TValue): void {\n if (this._map.has(key)) throw new Error(\"An item with the same key has already been added.\");\n this._map.set(key, value);\n this.Sync();\n }\n\n public Set(key: TKey, value: TValue): void {\n this._map.set(key, value);\n this.Sync();\n }\n\n public Get(key: TKey): TValue {\n const val = this._map.get(key);\n if (val === undefined) throw new Error(\"The given key was not present in the dictionary.\");\n return val;\n }\n\n public ContainsKey(key: TKey): boolean {\n return this._map.has(key);\n }\n\n public Remove(key: TKey): boolean {\n if (this._map.delete(key)) {\n this.Sync();\n return true;\n }\n return false;\n }\n private Sync(): void {\n this._items = Array.from(this._map.entries()).map(([k, v]) => new KeyValuePair(k, v));\n }\n\n public get Keys(): Enumerable { return new Enumerable(this._map.keys()); }\n public get Values(): Enumerable { return new Enumerable(this._map.values()); }\n\n public Add(key: TKey, value: TValue): void {\n if (this.ContainsKey(key)) throw new Error(\"An item with the same key has already been added.\");\n this._map.set(key, value); // Standard Map set\n this.Sync();\n }\n\n public Set(key: TKey, value: TValue): void {\n this._map.set(key, value);\n this.Sync();\n }\n\n public Get(key: TKey): TValue {\n const val = this._map.get(key);\n if (val === undefined) throw new Error(\"The given key was not present in the dictionary.\");\n return val;\n }\n\n public ContainsKey(key: TKey): boolean {\n return this._map.has(key);\n }\n\n}\n\nexport class HashSet extends Enumerable {\n private _set: Set;\n\n constructor(items?: T[] | Iterable) {\n super(items);\n this._set = new Set(this._items);\n }\n\n public Add(item: T): boolean {\n if (this._set.has(item)) return false;\n this._set.add(item);\n this.Sync();\n return true;\n }\n\n public Contains(item: T): boolean { return this._set.has(item); }\n\n public Remove(item: T): boolean {\n if (this._set.delete(item)) {\n this.Sync();\n return true;\n }\n return false;\n }\n\n private Sync(): void {\n this._items = Array.from(this._set);\n }\n}\n\nexport class List extends Enumerable {\n public Add(item: T): void {\n this._items.push(item);\n }\n public AddRange(items: Iterable): void {\n this._items.push(...Array.from(items));\n }\n public Clear(): void {\n this._items.length = 0;\n }\n public RemoveAt(index: number): void {\n this._items.splice(index, 1);\n }\n public Find(predicate: (item: T) => boolean): T | null {\n return this._items.find(predicate) ?? null;\n }\n\n public FindAll(predicate: (item: T) => boolean): List {\n return new List(this._items.filter(predicate));\n }\n\n /** C# PARITY: list.FindIndex(predicate) */\n public FindIndex(predicate: (item: T) => boolean): number {\n return this._items.findIndex(predicate);\n }\n\n /** C# PARITY: list.LastIndexOf(item) */\n public LastIndexOf(item: T): number {\n return this._items.lastIndexOf(item);\n }\n\n /** C# PARITY: list.Insert(index, item) */\n public Insert(index: number, item: T): void {\n this._items.splice(index, 0, item);\n }\n\n /** C# PARITY: list.InsertRange(index, items) */\n public InsertRange(index: number, items: Iterable): void {\n const itemsArray = Array.from(items);\n this._items.splice(index, 0, ...itemsArray);\n }\n\n /** C# PARITY: list.Remove(item) */\n public Remove(item: T): boolean {\n const index = this._items.indexOf(item);\n if (index > -1) {\n this._items.splice(index, 1);\n return true;\n }\n return false;\n }\n\n /** C# PARITY: list.RemoveAll(predicate) */\n public RemoveAll(predicate: (item: T) => boolean): number {\n const initialCount = this._items.length;\n this._items = this._items.filter(item => !predicate(item));\n return initialCount - this._items.length;\n }\n\n /** C# PARITY: list.RemoveRange(index, count) */\n public RemoveRange(index: number, count: number): void {\n this._items.splice(index, count);\n }\n\n /** C# PARITY: list.Reverse() */\n public Reverse(): void {\n this._items.reverse();\n }\n\n /** C# PARITY: list.Sort(comparer) */\n public Sort(comparer?: (a: T, b: T) => number): void {\n if (comparer) {\n this._items.sort(comparer);\n } else {\n // Default sort for comparable types (numbers, strings)\n this._items.sort();\n }\n }\n\n /** C# PARITY: list.ToArray() returns a T[] (already implemented on Enumerable) */\n // public ToArray(): T[] { return Array.from(this._items); }\n\n /** C# PARITY: list.ConvertAll(selector) */\n public ConvertAll(converter: (item: T) => TOutput): List {\n return new List(this._items.map(converter));\n }\n\n}\n\n\n\n// --- Refinements and New Classes for Enhanced C# Compliance ---\n\n// --- 1. OrderedEnumerable (Refined for better chaining and compliance) ---\n\n/**\n * Represents a sequence that has been ordered by one or more keys.\n * Corresponds to C# IOrderedEnumerable.\n * This implementation uses lazy sorting (like C#) by storing sort criteria and applying them on demand.\n */\n\n\n// --- Tier 1: Core Linq Methods and Parity Refinements (Highest Priority) ---\n\n// --- 1. Enumerable Static Methods (Parity with System.Linq.Enumerable) ---\n// Note: These will be added as static methods to the existing Enumerable class, not as new classes.\n// No new classes needed here, but the implementation should be added to `Enumerable`.\n\n// --- 2. Collection Initializers and Constructors ---\n// No new classes needed, just enhancing existing constructors.\n\n// --- 3. Basic Linq Operations (SelectMany, Take, Skip, TakeWhile, SkipWhile) ---\n// No new classes needed, just adding methods to `Enumerable`.\n\n// --- 4. Equality and Comparison (SequenceEqual, Contains) ---\n// No new classes needed, just adding methods to `Enumerable`.\n\n// --- 5. Grouping ---\n/**\n * Represents a sequence of objects that share a common key.\n * Corresponds to C# IGrouping where TElement is the type of the items.\n */\n\nexport class Grouping extends Enumerable {\n public readonly Key: TKey;\n\n /** Private constructor to prevent direct instantiation, enforcing creation via Enumerable.GroupBy(). */\n private constructor(key: TKey, elements: Iterable) {\n super(elements);\n this.Key = key;\n }\n\n /** Factory method used by Enumerable.GroupBy to create Grouping instances. */\n public static create(key: TKey, elements: Iterable): Grouping {\n return new Grouping(key, elements);\n }\n}\n\n\n// --- Tier 2: Advanced Linq Operations and Interfaces (Mid Priority) ---\n\n// --- 4. Sorting Enhancements (ThenBy) ---\n/**\n * Represents a sequence that has been ordered by one or more keys.\n * Used internally to chain multiple OrderBy/ThenBy operations.\n * Corresponds to C# IOrderedEnumerable.\n */\nexport class OrderedEnumerable extends Enumerable {\n // A comparator function created by chaining OrderBy/ThenBy calls.\n private _comparator: (a: T, b: T) => number;\n\n constructor(source: T[], comparator: (a: T, b: T) => number) {\n // We defer sorting until enumeration (or ToArray/ToList call) in C#,\n // but for simplicity here, we'll sort upon creation in JS.\n super(source.sort(comparator));\n this._comparator = comparator;\n }\n\n /**\n * Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.\n * @param selector A function to extract the key for each element.\n */\n public ThenBy(selector: (item: T) => TKey): OrderedEnumerable {\n return this.createNextOrderedEnumerable(selector, false);\n }\n\n /**\n * Performs a subsequent ordering of the elements in a sequence in descending order according to a key.\n * @param selector A function to extract the key for each element.\n */\n public ThenByDescending(selector: (item: T) => TKey): OrderedEnumerable {\n return this.createNextOrderedEnumerable(selector, true);\n }\n\n private createNextOrderedEnumerable(\n selector: (item: T) => TKey,\n descending: boolean\n ): OrderedEnumerable {\n // Create a new comparator that combines the previous sort logic with the new one.\n const nextComparator = (a: T, b: T) => {\n const previousResult = this._comparator(a, b);\n if (previousResult !== 0) {\n return previousResult;\n }\n\n const keyA = selector(a);\n const keyB = selector(b);\n if (keyA > keyB) {\n return descending ? -1 : 1;\n }\n if (keyA < keyB) {\n return descending ? 1 : -1;\n }\n return 0;\n };\n\n // Re-sort the original array using the new chained comparator.\n // C# Linq uses lazy evaluation, but here we re-sort to maintain a single sorted array for simplicity.\n return new OrderedEnumerable(this._items, nextComparator);\n }\n}\n\n// --- Tier 3: Supporting Classes and Data Structures ---\n\n// --- 1. SortedDictionary ---\n/**\n * Represents a collection of key/value pairs that are sorted by key.\n * Corresponds to C# SortedDictionary.\n */\nexport class SortedDictionary extends Dictionary {\n // A custom comparator function for TKey. Default uses basic comparison.\n private _keyComparator: (a: TKey, b: TKey) => number;\n\n constructor(keyComparator?: (a: TKey, b: TKey) => number) {\n super();\n this._keyComparator = keyComparator || this.defaultComparator;\n }\n\n /** C# PARITY: dictionary.Add(key, value) */\n public Add(key: TKey, value: TValue): void {\n if (this.ContainsKey(key)) throw new Error(\"An item with the same key has already been added.\");\n this.Set(key, value); // Call Set to handle internal sorting logic\n }\n\n /** C# PARITY: dictionary[key] = value */\n public Set(key: TKey, value: TValue): void {\n super.Set(key, value); // Use existing map logic\n this.Sync(true); // Sync with sorting enabled\n }\n\n public Remove(key: TKey): boolean {\n if (super.Remove(key)) {\n this.Sync(true); // Sync with sorting enabled\n return true;\n }\n return false;\n }\n\n /** Keeps the Enumerable _items in sync with the internal Map, applying sorting logic. */\n protected Sync(sorted: boolean = false): void {\n this._items = Array.from(this._map.entries()).map(([k, v]) => new KeyValuePair(k, v));\n if (sorted) {\n this._items.sort((a, b) => this._keyComparator(a.Key, b.Key));\n }\n }\n\n private defaultComparator(a: TKey, b: TKey): number {\n if (a > b) return 1;\n if (a < b) return -1;\n return 0;\n }\n}\n\n export class SortedDictionary extends Dictionary {\n // A custom comparator function for TKey. Default uses basic comparison.\n private _keyComparator: (a: TKey, b: TKey) => number;\n\n constructor(keyComparator?: (a: TKey, b: TKey) => number) {\n super();\n this._keyComparator = keyComparator || this.defaultComparator;\n // The base class needs to be modified to use a sorted internal structure (like Map)\n // or re-sort on every modification if we're extending `Dictionary`.\n }\n\n /** C# PARITY: dictionary.Add(key, value) */\n public override Add(key: TKey, value: TValue): void {\n // Enforce uniqueness\n if (this.ContainsKey(key)) throw new Error(\"An item with the same key has already been added.\");\n this.Set(key, value);\n }\n\n /** C# PARITY: dictionary[key] = value */\n public override Set(key: TKey, value: TValue): void {\n super.Set(key, value); // Let base Dictionary handle internal Map logic\n this.Sync(); // Re-sync the enumerable list to maintain sort order.\n }\n\n public override Remove(key: TKey): boolean {\n if (super.Remove(key)) {\n this.Sync();\n return true;\n }\n return false;\n }\n\n /** Ensures the Enumerable _items are sorted correctly. */\n protected override Sync(): void {\n super.Sync(); // First get the up-to-date items from the base Dictionary Map.\n this._items.sort((a, b) => this._keyComparator(a.Key, b.Key));\n }\n\n /** Default comparator for primitive types. */\n private defaultComparator(a: TKey, b: TKey): number {\n if (typeof a === 'string' && typeof b === 'string') {\n return a.localeCompare(b);\n }\n if (a > b) return 1;\n if (a < b) return -1;\n return 0;\n }\n}\n\n\n// --- 2. SortedList ---\n/**\n * Represents a list of key/value pairs that are sorted by key.\n * Corresponds to C# SortedList.\n * Note: A SortedList maintains two parallel arrays for keys and values,\n * which offers better performance characteristics than SortedDictionary in some scenarios.\n * For simplicity in TypeScript, we'll keep the SortedDictionary implementation a bit simpler\n * to maintain C# parity. The internal implementation here uses the same base logic.\n */\n// In C#, SortedList is distinct from SortedDictionary.\n// In TypeScript, we can reuse much of the SortedDictionary logic for simplicity,\n// but for true parity, we'd implement it to internally maintain a sorted array/list structure instead of Map.\n// For now, let's keep it simple to avoid code duplication, but for true compliance, it would be a separate implementation.\nexport class SortedList extends SortedDictionary {\n // In C#, SortedList has additional properties like Capacity.\n // We are extending SortedDictionary here for simplicity.\n // For full compliance, this class would have a different internal implementation (likely array-based)\n // to match C# performance characteristics.\n}\n\n// --- 3. Queue and Stack ---\n\n/**\n * Represents a first-in, first-out (FIFO) collection of objects.\n * Corresponds to C# Queue.\n */\nexport class Queue extends Enumerable {\n constructor(items?: Iterable) {\n super(items);\n }\n\n /** Adds an object to the end of the Queue. */\n public Enqueue(item: T): void {\n this._items.push(item);\n }\n\n /** Removes and returns the object at the beginning of the Queue. */\n public Dequeue(): T {\n if (this._items.length === 0) throw new Error(\"Queue is empty.\");\n // shift() removes from the start (FIFO)\n return this._items.shift()!;\n }\n\n /** Returns the object at the beginning of the Queue without removing it. */\n public Peek(): T {\n if (this._items.length === 0) throw new Error(\"Queue is empty.\");\n return this._items[0];\n }\n\n /** Determines whether an element is in the Queue. */\n public Contains(item: T): boolean {\n return this._items.includes(item);\n }\n}\n\n/**\n * Represents a last-in, first-out (LIFO) collection of objects.\n * Corresponds to C# Stack.\n */\nexport class Stack extends Enumerable {\n constructor(items?: Iterable) {\n super(items);\n }\n\n /** Inserts an object at the top of the Stack. */\n public Push(item: T): void {\n this._items.push(item);\n }\n\n /** Removes and returns the object at the top of the Stack. */\n public Pop(): T {\n if (this._items.length === 0) throw new Error(\"Stack is empty.\");\n // pop() removes from the end (LIFO)\n return this._items.pop()!;\n }\n\n /** Returns the object at the top of the Stack without removing it. */\n public Peek(): T {\n if (this._items.length === 0) throw new Error(\"Stack is empty.\");\n return this._items[this._items.length - 1];\n }\n\n /** Determines whether an element is in the Stack. */\n public Contains(item: T): boolean {\n return this._items.includes(item);\n }\n}\n// --- 2. Grouping (Refined and C# compliant) ---\n\n/**\n * Represents a sequence of objects that share a common key.\n * Corresponds to C# IGrouping.\n * The constructor is private; instances are created only by the Enumerable.GroupBy method.\n */\n\n\n// --- 3. Dictionary and SortedDictionary (Refined for better C# compliance) ---\n\n/**\n * Represents a collection of key/value pairs that are sorted by key.\n * Corresponds to C# SortedDictionary.\n * Implements C# behavior where keys are automatically sorted upon insertion.\n */\n\n\n// --- 4. Queue and Stack (Refined for better C# compliance) ---\n\n/**\n * Represents a first-in, first-out (FIFO) collection of objects.\n * Corresponds to C# Queue.\n * Uses a standard array internally for storage.\n */\nexport class Queue extends Enumerable {\n constructor(items?: Iterable) {\n super(items);\n }\n\n /** Adds an object to the end of the Queue. */\n public Enqueue(item: T): void {\n this._items.push(item);\n }\n\n /** Removes and returns the object at the beginning of the Queue. */\n public Dequeue(): T {\n if (this._items.length === 0) throw new Error(\"Queue is empty.\");\n // shift() removes from the start (FIFO)\n return this._items.shift()!;\n }\n\n /** Returns the object at the beginning of the Queue without removing it. */\n public Peek(): T {\n if (this._items.length === 0) throw new Error(\"Queue is empty.\");\n return this._items[0];\n }\n\n /** Determines whether an element is in the Queue. */\n public Contains(item: T): boolean {\n return this._items.includes(item);\n }\n}\n\n/**\n * Represents a last-in, first-out (LIFO) collection of objects.\n * Corresponds to C# Stack.\n * Uses a standard array internally for storage.\n */\nexport class Stack extends Enumerable {\n constructor(items?: Iterable) {\n super(items);\n }\n\n /** Inserts an object at the top of the Stack. */\n public Push(item: T): void {\n this._items.push(item);\n }\n\n /** Removes and returns the object at the top of the Stack. */\n public Pop(): T {\n if (this._items.length === 0) throw new Error(\"Stack is empty.\");\n // pop() removes from the end (LIFO)\n return this._items.pop()!;\n }\n\n /** Returns the object at the top of the Stack without removing it. */\n public Peek(): T {\n if (this._items.length === 0) throw new Error(\"Stack is empty.\");\n return this._items[this._items.length - 1];\n }\n\n /** Determines whether an element is in the Stack. */\n public Contains(item: T): boolean {\n return this._items.includes(item);\n }\n}\n\n\n\n// --- Refinements and New Classes for Enhanced C# Compliance ---\n\n// --- Tier 2: Advanced Linq Operations and Interfaces (Mid Priority) ---\n\n// --- 1. Set Operations (Distinct, Union, Intersect, Except) ---\n// No new classes needed, just adding methods to Enumerable.\n\n// --- 2. Joining and Concatenation (Join, Concat) ---\n// No new classes needed, just adding methods to Enumerable.\n\n// --- 3. Element Access (ElementAt) ---\n// No new classes needed, just adding methods to Enumerable.\n\n// --- 4. Sorting Enhancements (ThenBy) ---\n// See previous response for `OrderedEnumerable` implementation.\n\n// --- 5. Advanced Linq Operators (Chunk) ---\n// No new classes needed, just adding methods to Enumerable.\n\n// --- Tier 3: Supporting Classes and Data Structures ---\n\n// --- 1. SortedDictionary ---\n// See previous response for `SortedDictionary` implementation.\n\n// --- 2. SortedList ---\n/**\n * Represents a list of key/value pairs that are sorted by key.\n * Corresponds to C# SortedList.\n *\n * NOTE: C# SortedList maintains two parallel arrays and offers different\n * performance trade-offs compared to SortedDictionary (which uses a red-black tree).\n * For TypeScript parity, we implement similar behavior by extending Enumerable\n * and managing the sorted `_items` array (where items are KeyValuePairs).\n */\nexport class SortedList extends Enumerable> {\n private _map = new Map();\n private _keyComparator: (a: TKey, b: TKey) => number;\n\n constructor(keyComparator?: (a: TKey, b: TKey) => number) {\n super();\n this._keyComparator = keyComparator || this.defaultComparator;\n }\n\n /** C# PARITY: list.Add(key, value) */\n public Add(key: TKey, value: TValue): void {\n if (this._map.has(key)) throw new Error(\"An item with the same key has already been added.\");\n this.Set(key, value);\n }\n\n /** C# PARITY: list[key] = value */\n public Set(key: TKey, value: TValue): void {\n this._map.set(key, value);\n this.Sync();\n }\n\n /** C# PARITY: var val = list[key] */\n public Get(key: TKey): TValue {\n const val = this._map.get(key);\n if (val === undefined) throw new Error(\"The given key was not present in the dictionary.\");\n return val;\n }\n\n public ContainsKey(key: TKey): boolean {\n return this._map.has(key);\n }\n\n /** C# PARITY: list.Remove(key) */\n public Remove(key: TKey): boolean {\n if (this._map.delete(key)) {\n this.Sync();\n return true;\n }\n return false;\n }\n\n /** C# PARITY: list.RemoveAt(index) */\n public RemoveAt(index: number): void {\n const key = this._items[index]?.Key;\n if (key === undefined) throw new Error(\"Index was outside the bounds of the array.\");\n this.Remove(key);\n }\n\n /** Keeps the Enumerable _items in sync with the internal Map, applying sorting logic. */\n protected Sync(): void {\n this._items = Array.from(this._map.entries()).map(([k, v]) => new KeyValuePair(k, v));\n this._items.sort((a, b) => this._keyComparator(a.Key, b.Key));\n }\n\n private defaultComparator(a: TKey, b: TKey): number {\n if (a > b) return 1;\n if (a < b) return -1;\n return 0;\n }\n\n /** C# PARITY: list.Keys property */\n public get Keys(): Enumerable { return new Enumerable(this._items.map(pair => pair.Key)); }\n\n /** C# PARITY: list.Values property */\n public get Values(): Enumerable { return new Enumerable(this._items.map(pair => pair.Value)); }\n}\n\n// --- 3. LinkedList ---\n/**\n * Represents a doubly linked list.\n * Corresponds to C# LinkedList.\n * Uses internal nodes for efficient insertions and removals at arbitrary positions.\n */\n\n/** A single node within the LinkedList. */\nexport class LinkedListNode {\n constructor(\n public Value: T,\n public List: LinkedList, // Reference back to the parent list\n public next: LinkedListNode | null = null,\n public previous: LinkedListNode | null = null\n ) { }\n}\n\n/** The main LinkedList class. */\nexport class LinkedList extends Enumerable {\n public First: LinkedListNode | null = null;\n public Last: LinkedListNode | null = null;\n\n constructor(items?: Iterable) {\n super(); // Initialize Enumerable base without data immediately\n if (items) {\n this.AddRange(items);\n }\n }\n\n /** C# PARITY: list.Count property */\n public override get Count(): number {\n let count = 0;\n let current = this.First;\n while (current) {\n count++;\n current = current.next;\n }\n return count;\n }\n\n /** C# PARITY: list.AddFirst(value) */\n public AddFirst(value: T): LinkedListNode {\n const newNode = new LinkedListNode(value, this);\n if (this.First) {\n newNode.next = this.First;\n this.First.previous = newNode;\n } else {\n this.Last = newNode;\n }\n this.First = newNode;\n this.Sync();\n return newNode;\n }\n\n /** C# PARITY: list.AddLast(value) */\n public AddLast(value: T): LinkedListNode {\n const newNode = new LinkedListNode(value, this);\n if (this.Last) {\n newNode.previous = this.Last;\n this.Last.next = newNode;\n } else {\n this.First = newNode;\n }\n this.Last = newNode;\n this.Sync();\n return newNode;\n }\n\n /** C# PARITY: list.Remove(node) */\n public Remove(node: LinkedListNode): boolean {\n if (node.List !== this) {\n throw new Error(\"Node does not belong to this list.\");\n }\n\n if (node === this.First) {\n this.First = node.next;\n }\n if (node === this.Last) {\n this.Last = node.previous;\n }\n\n if (node.previous) {\n node.previous.next = node.next;\n }\n if (node.next) {\n node.next.previous = node.previous;\n }\n\n this.Sync();\n return true;\n }\n\n /** C# PARITY: list.RemoveFirst() */\n public RemoveFirst(): void {\n if (!this.First) throw new Error(\"List is empty.\");\n this.Remove(this.First);\n }\n\n /** C# PARITY: list.RemoveLast() */\n public RemoveLast(): void {\n if (!this.Last) throw new Error(\"List is empty.\");\n this.Remove(this.Last);\n }\n\n /** C# PARITY: list.Find(value) */\n public Find(value: T): LinkedListNode | null {\n let current = this.First;\n while (current) {\n if (current.Value === value) {\n return current;\n }\n current = current.next;\n }\n return null;\n }\n\n /** C# PARITY: list.Clear() */\n public Clear(): void {\n this.First = null;\n this.Last = null;\n this.Sync();\n }\n\n /** Synchronizes the internal `_items` array for Enumerable functionality. */\n protected Sync(): void {\n this._items.length = 0; // Clear the array first\n let current = this.First;\n while (current) {\n this._items.push(current.Value);\n current = current.next;\n }\n }\n\n /** C# PARITY: list.AddRange(items) */\n public AddRange(items: Iterable): void {\n for (const item of items) {\n this.AddLast(item);\n }\n }\n}\n\n\n\n// --- Refinements and New Classes for Enhanced C# Compliance ---\n\n// --- Tier 3: Supporting Classes and Data Structures (Continued) ---\n\n// --- 4. ReadOnlyCollection ---\n/**\n * Provides the base class for a generic read-only collection.\n * Corresponds to C# ReadOnlyCollection.\n * Note: C# ReadOnlyCollection wraps an existing List. Changes to the underlying list\n * are reflected in the ReadOnlyCollection.\n */\nexport class ReadOnlyCollection extends Enumerable {\n constructor(list: List) {\n // We link directly to the underlying list's internal array reference.\n // This ensures the ReadOnlyCollection reflects changes made to the source list.\n super(list);\n // We reassign the internal items array to match the source list's items array reference.\n this._items = (list as any)._items;\n }\n\n // Override methods to prevent modifications (C# compliance)\n // C# ReadOnlyCollection methods like Add/Remove are not present, or throw NotSupportedException if implemented via interface.\n\n /** Prevent direct modification of the internal array. */\n public override Add(item: T): never {\n throw new Error(\"Cannot modify a ReadOnlyCollection.\");\n }\n\n public override Clear(): never {\n throw new Error(\"Cannot modify a ReadOnlyCollection.\");\n }\n\n public override RemoveAt(index: number): never {\n throw new Error(\"Cannot modify a ReadOnlyCollection.\");\n }\n\n public override AddRange(items: Iterable): never {\n throw new Error(\"Cannot modify a ReadOnlyCollection.\");\n }\n\n /** C# PARITY: Indexer access via GetAt */\n public GetAt(index: number): T { return this._items[index]; }\n}\n\n// --- 5. ReadOnlyDictionary ---\n/**\n * Provides a read-only wrapper around a generic dictionary.\n * Corresponds to C# ReadOnlyDictionary.\n * Note: C# ReadOnlyDictionary wraps an existing Dictionary. Changes to the underlying dictionary\n * are reflected in the ReadOnlyDictionary.\n */\nexport class ReadOnlyDictionary extends Dictionary {\n private _sourceDictionary: Dictionary;\n\n constructor(dictionary: Dictionary) {\n super(); // Initialize Enumerable base without data immediately\n this._sourceDictionary = dictionary;\n\n // Ensure internal state syncs with the source dictionary.\n // For C# compliance, we want a live view, so we override methods to delegate to the source.\n }\n\n // --- Overrides to prevent modification ---\n\n public override Add(key: TKey, value: TValue): never {\n throw new Error(\"Cannot modify a ReadOnlyDictionary.\");\n }\n\n public override Set(key: TKey, value: TValue): never {\n throw new Error(\"Cannot modify a ReadOnlyDictionary.\");\n }\n\n public override Remove(key: TKey): never {\n throw new Error(\"Cannot modify a ReadOnlyDictionary.\");\n }\n\n // --- Overrides to delegate read operations to source dictionary ---\n\n public override ContainsKey(key: TKey): boolean {\n return this._sourceDictionary.ContainsKey(key);\n }\n\n public override Get(key: TKey): TValue {\n return this._sourceDictionary.Get(key);\n }\n\n public override get Keys(): Enumerable {\n return this._sourceDictionary.Keys;\n }\n\n public override get Values(): Enumerable {\n return this._sourceDictionary.Values;\n }\n\n public override get Count(): number {\n return this._sourceDictionary.Count;\n }\n\n public override ToArray(): KeyValuePair[] {\n return this._sourceDictionary.ToArray();\n }\n\n public override [Symbol.iterator](): Iterator> {\n return this._sourceDictionary[Symbol.iterator]();\n }\n}\n\n\n// --- 6. ConcurrentDictionary (Advanced compliance) ---\n/**\n * Represents a thread-safe collection of key/value pairs that can be accessed by multiple threads concurrently.\n * Corresponds to C# ConcurrentDictionary.\n * In JavaScript, concurrency is different (single-threaded event loop), but we can simulate C# behavior\n * by providing non-blocking methods and ensuring a single \"atomic\" operation (e.g., compare and swap logic)\n * for C# compliance, even if JS doesn't have true multi-threading in the same way.\n */\nexport class ConcurrentDictionary extends Dictionary {\n\n /** C# PARITY: TryAdd(key, value) */\n public TryAdd(key: TKey, value: TValue): boolean {\n if (!this.ContainsKey(key)) {\n this.Set(key, value);\n return true;\n }\n return false;\n }\n\n /** C# PARITY: TryGetValue(key, out value) */\n public TryGetValue(key: TKey): TValue | undefined {\n // In C#, this method uses an `out` parameter. In TypeScript, we return TValue | undefined.\n if (this.ContainsKey(key)) {\n return super.Get(key);\n }\n return undefined;\n }\n\n /** C# PARITY: TryRemove(key, out value) */\n public TryRemove(key: TKey): TValue | undefined {\n if (this.ContainsKey(key)) {\n const value = super.Get(key);\n this.Remove(key);\n return value;\n }\n return undefined;\n }\n\n /** C# PARITY: AddOrUpdate(key, addValueFactory, updateValueFactory) */\n public AddOrUpdate(key: TKey, addValueFactory: () => TValue, updateValueFactory: (key: TKey, existingValue: TValue) => TValue): TValue {\n if (this.ContainsKey(key)) {\n const existingValue = super.Get(key);\n const newValue = updateValueFactory(key, existingValue);\n this.Set(key, newValue);\n return newValue;\n } else {\n const newValue = addValueFactory();\n this.Set(key, newValue);\n return newValue;\n }\n }\n}\n\n\n\n// --- Refinements and New Classes for Enhanced C# Compliance ---\n\n// --- Tier 3: Supporting Classes and Data Structures (Continued) ---\n\n// --- 7. ObservableCollection ---\n/**\n * Represents a dynamic data collection that provides notifications when items get added, removed, or when the whole list is refreshed.\n * Corresponds to C# ObservableCollection.\n * Uses a basic event system to notify subscribers (observers).\n */\n\n/** Defines the type of collection change event. */\nexport enum NotifyCollectionChangedAction {\n Add = \"Add\",\n Remove = \"Remove\",\n Replace = \"Replace\",\n Move = \"Move\",\n Reset = \"Reset\"\n}\n\n/** Interface for collection change event arguments. */\nexport interface NotifyCollectionChangedEventArgs {\n action: NotifyCollectionChangedAction;\n oldItems?: T[]; // Items involved in Remove, Replace, or Move operations\n newItems?: T[]; // Items involved in Add, Replace, or Move operations\n newStartingIndex?: number; // Starting index for items added (Add, Replace, Move)\n oldStartingIndex?: number; // Starting index for items removed (Remove, Replace, Move)\n}\n\n/** Delegate type for collection change event handler. */\nexport type NotifyCollectionChangedEventHandler = (sender: ObservableCollection, args: NotifyCollectionChangedEventArgs) => void;\n\n/** The main ObservableCollection class. */\nexport class ObservableCollection extends List {\n private _handlers: NotifyCollectionChangedEventHandler[] = [];\n\n /** C# PARITY: CollectionChanged event subscription */\n public addEventListener(handler: NotifyCollectionChangedEventHandler): void {\n this._handlers.push(handler);\n }\n\n /** C# PARITY: CollectionChanged event unsubscription */\n public removeEventListener(handler: NotifyCollectionChangedEventHandler): void {\n this._handlers = this._handlers.filter(h => h !== handler);\n }\n\n protected onCollectionChanged(args: NotifyCollectionChangedEventArgs): void {\n for (const handler of this._handlers) {\n handler(this, args);\n }\n }\n\n // --- Override List methods to trigger events ---\n\n public override Add(item: T): void {\n super.Add(item);\n this.onCollectionChanged({\n action: NotifyCollectionChangedAction.Add,\n newItems: [item],\n newStartingIndex: this.Count - 1\n });\n }\n\n public override AddRange(items: Iterable): void {\n const newItems = Array.from(items);\n const startIndex = this.Count;\n super.AddRange(newItems);\n // C# ObservableCollection sometimes fires a single Reset event for AddRange,\n // especially for large ranges, for performance reasons. Here, we'll keep it simple\n // and fire a single \"Reset\" event if multiple items are added to avoid complex logic.\n this.onCollectionChanged({\n action: NotifyCollectionChangedAction.Reset\n });\n }\n\n public override Clear(): void {\n super.Clear();\n this.onCollectionChanged({ action: NotifyCollectionChangedAction.Reset });\n }\n\n public override RemoveAt(index: number): void {\n const oldItem = this._items[index];\n super.RemoveAt(index);\n this.onCollectionChanged({\n action: NotifyCollectionChangedAction.Remove,\n oldItems: [oldItem],\n oldStartingIndex: index\n });\n }\n\n public SetAt(index: number, value: T): void {\n const oldItem = this._items[index];\n super.SetAt(index, value); // Assumes base List has a SetAt method\n this.onCollectionChanged({\n action: NotifyCollectionChangedAction.Replace,\n oldItems: [oldItem],\n newItems: [value],\n newStartingIndex: index,\n oldStartingIndex: index\n });\n }\n}\n\n\n// --- 8. ImmutableArray / ImmutableList (Advanced compliance) ---\n/**\n * Represents an array or list that cannot be changed after it is created.\n * Corresponds to C# ImmutableArray and ImmutableList.\n * These methods return new instances instead of modifying the existing one.\n */\n\n/** The core immutable list implementation. */\nexport class ImmutableList extends Enumerable {\n constructor(items?: Iterable) {\n super(items);\n }\n\n /** C# PARITY: Add(item) returns a new ImmutableList instance. */\n public Add(item: T): ImmutableList {\n return new ImmutableList([...this._items, item]);\n }\n\n /** C# PARITY: AddRange(items) returns a new ImmutableList instance. */\n public AddRange(items: Iterable): ImmutableList {\n return new ImmutableList([...this._items, ...Array.from(items)]);\n }\n\n /** C# PARITY: Remove(item) returns a new ImmutableList instance. */\n public Remove(item: T): ImmutableList {\n const index = this._items.indexOf(item);\n if (index === -1) {\n return this; // Return existing instance if item not found (C# behavior)\n }\n return new ImmutableList(this._items.slice(0, index).concat(this._items.slice(index + 1)));\n }\n\n /** C# PARITY: RemoveAt(index) returns a new ImmutableList instance. */\n public RemoveAt(index: number): ImmutableList {\n if (index < 0 || index >= this._items.length) {\n throw new Error(\"Index out of range.\");\n }\n return new ImmutableList(this._items.slice(0, index).concat(this._items.slice(index + 1)));\n }\n\n /** C# PARITY: Clear() returns an empty ImmutableList instance. */\n public Clear(): ImmutableList {\n return new ImmutableList([]);\n }\n\n /** C# PARITY: SetItem(index, value) returns a new ImmutableList instance. */\n public SetItem(index: number, value: T): ImmutableList {\n if (index < 0 || index >= this._items.length) {\n throw new Error(\"Index out of range.\");\n }\n const newItems = [...this._items];\n newItems[index] = value;\n return new ImmutableList(newItems);\n }\n}\n\n// --- 9. ImmutableDictionary ---\n/**\n * Represents an immutable collection of key/value pairs.\n * Corresponds to C# ImmutableDictionary.\n */\nexport class ImmutableDictionary extends Dictionary {\n\n // Internal Map for data storage (like Dictionary base)\n private _map = new Map();\n\n constructor(items?: Iterable>) {\n super(); // Initialize Enumerable base without data immediately\n if (items) {\n for (const item of items) {\n this._map.set(item.Key, item.Value);\n }\n }\n this.Sync();\n }\n\n /** C# PARITY: Add(key, value) returns a new ImmutableDictionary instance. */\n public override Add(key: TKey, value: TValue): ImmutableDictionary {\n const newItems = [...this._map.entries()];\n if (this._map.has(key)) throw new Error(\"An item with the same key has already been added.\");\n newItems.push([key, value]);\n return new ImmutableDictionary(newItems.map(([k, v]) => new KeyValuePair(k, v)));\n }\n\n /** C# PARITY: SetItem(key, value) returns a new ImmutableDictionary instance. */\n public SetItem(key: TKey, value: TValue): ImmutableDictionary {\n const newMap = new Map(this._map);\n newMap.set(key, value);\n return new ImmutableDictionary(Array.from(newMap.entries()).map(([k, v]) => new KeyValuePair(k, v)));\n }\n\n /** C# PARITY: Remove(key) returns a new ImmutableDictionary instance. */\n public override Remove(key: TKey): ImmutableDictionary {\n if (!this._map.has(key)) return this; // Return existing instance if key not found (C# behavior)\n const newMap = new Map(this._map);\n newMap.delete(key);\n return new ImmutableDictionary(Array.from(newMap.entries()).map(([k, v]) => new KeyValuePair(k, v)));\n }\n\n /** Keeps the Enumerable _items in sync with the internal Map */\n protected override Sync(): void {\n this._items = Array.from(this._map.entries()).map(([k, v]) => new KeyValuePair(k, v));\n }\n\n // --- Overrides to prevent modification from base methods ---\n public override get Keys(): Enumerable { return new Enumerable(this._map.keys()); }\n public override get Values(): Enumerable { return new Enumerable(this._map.values()); }\n public override get Count(): number { return this._map.size; }\n public override Get(key: TKey): TValue { return super.Get(key); }\n public override ContainsKey(key: TKey): boolean { return super.ContainsKey(key); }\n}\n\n\n// --- Refinements and New Classes for Enhanced C# Compliance ---\n\n// --- Tier 3: Supporting Classes and Data Structures (Continued) ---\n\n// --- 10. BitArray ---\n/**\n * Manages a compact array of bit values, which are represented as booleans.\n * Corresponds to C# BitArray.\n * Allows efficient storage and manipulation of boolean flags.\n */\nexport class BitArray {\n private _bits: Uint8Array;\n private _length: number;\n\n /**\n * Initializes a new instance of the BitArray class.\n * @param length The number of elements in the array.\n * @param defaultValue The initial value of all elements (true or false). Defaults to false.\n */\n constructor(length: number, defaultValue: boolean = false) {\n if (length < 0) throw new Error(\"Length must be non-negative.\");\n this._length = length;\n this._bits = new Uint8Array(Math.ceil(length / 8));\n\n if (defaultValue) {\n this._bits.fill(0xFF); // Fill all bytes with 1s (0xFF)\n }\n }\n\n /** C# PARITY: bitArray[index] = value */\n public set(index: number, value: boolean): void {\n this.checkBounds(index);\n const byteIndex = Math.floor(index / 8);\n const bitOffset = index % 8;\n\n if (value) {\n this._bits[byteIndex] |= (1 << bitOffset); // Set the bit to 1\n } else {\n this._bits[byteIndex] &= ~(1 << bitOffset); // Set the bit to 0\n }\n }\n\n /** C# PARITY: var value = bitArray[index] */\n public get(index: number): boolean {\n this.checkBounds(index);\n const byteIndex = Math.floor(index / 8);\n const bitOffset = index % 8;\n return (this._bits[byteIndex] & (1 << bitOffset)) !== 0;\n }\n\n /** C# PARITY: bitArray.Length property */\n public get Length(): number {\n return this._length;\n }\n\n /** C# PARITY: bitArray.Length = newLength */\n public set Length(value: number) {\n if (value < 0) throw new Error(\"Length must be non-negative.\");\n if (value === this._length) return;\n\n const newByteLength = Math.ceil(value / 8);\n const newBits = new Uint8Array(newByteLength);\n\n // Copy existing data to new array\n newBits.set(this._bits.slice(0, Math.min(this._bits.length, newByteLength)));\n\n // If expanding and default value is true, fill new part with ones\n if (value > this._length && newByteLength > this._bits.length) {\n const extraBytesToFill = newByteLength - this._bits.length;\n // Fill new bytes with 0xFF if default value was true, or leave as 0 if false.\n // This implementation assumes a default of false for expansion. For true compliance,\n // we'd need to track the initial default value.\n }\n\n this._bits = newBits;\n this._length = value;\n }\n\n /** C# PARITY: bitArray.And(other) */\n public And(bitArray: BitArray): BitArray {\n this.checkLengthMatch(bitArray);\n const result = new BitArray(this.Length);\n for (let i = 0; i < this._bits.length; i++) {\n result._bits[i] = this._bits[i] & bitArray._bits[i];\n }\n return result;\n }\n\n /** C# PARITY: bitArray.Or(other) */\n public Or(bitArray: BitArray): BitArray {\n this.checkLengthMatch(bitArray);\n const result = new BitArray(this.Length);\n for (let i = 0; i < this._bits.length; i++) {\n result._bits[i] = this._bits[i] | bitArray._bits[i];\n }\n return result;\n }\n\n /** C# PARITY: bitArray.Xor(other) */\n public Xor(bitArray: BitArray): BitArray {\n this.checkLengthMatch(bitArray);\n const result = new BitArray(this.Length);\n for (let i = 0; i < this._bits.length; i++) {\n result._bits[i] = this._bits[i] ^ bitArray._bits[i];\n }\n return result;\n }\n\n /** C# PARITY: bitArray.Not() */\n public Not(): BitArray {\n const result = new BitArray(this.Length);\n for (let i = 0; i < this._bits.length; i++) {\n result._bits[i] = ~this._bits[i];\n }\n return result;\n }\n\n /** C# PARITY: bitArray.SetAll(value) */\n public SetAll(value: boolean): void {\n const fillValue = value ? 0xFF : 0x00;\n this._bits.fill(fillValue);\n }\n\n private checkBounds(index: number): void {\n if (index < 0 || index >= this._length) {\n throw new Error(\"Index was outside the bounds of the array.\");\n }\n }\n\n private checkLengthMatch(other: BitArray): void {\n if (this.Length !== other.Length) {\n throw new Error(\"BitArray lengths must match for logical operations.\");\n }\n }\n\n /** Allows iteration over the BitArray values. */\n public [Symbol.iterator](): Iterator {\n let index = 0;\n const self = this;\n return {\n next(): IteratorResult {\n if (index < self._length) {\n const value = self.get(index);\n index++;\n return { value, done: false };\n }\n return { value: undefined, done: true };\n }\n };\n }\n}\n\n\n// --- 11. ReadOnlyList (Advanced compliance, similar to ReadOnlyCollection but with interface focus) ---\n/**\n * Provides a read-only view of a List.\n * This class primarily provides the C# `IList` read-only interface equivalent.\n * It ensures that standard array operations like `push` or `splice` cannot be used directly on the underlying storage.\n * Note: While `ReadOnlyCollection` wraps a `List`, this class focuses on providing read-only access to a source collection.\n */\nexport class ReadOnlyList extends Enumerable {\n constructor(source: T[] | Enumerable) {\n super(source); // Base class takes a copy of the array by default.\n }\n\n /** C# PARITY: ReadOnlyList does not have methods like Add/RemoveAt. */\n public override Add(item: T): never {\n throw new Error(\"Collection is read-only.\");\n }\n\n public override Clear(): never {\n throw new Error(\"Collection is read-only.\");\n }\n\n public override RemoveAt(index: number): never {\n throw new Error(\"Collection is read-only.\");\n }\n\n /** C# PARITY: Indexer access via GetAt. */\n public GetAt(index: number): T {\n return this._items[index];\n }\n}\n\n\n\n// --- Refinements and New Classes for Enhanced C# Compliance ---\n\n// --- Tier 3: Supporting Classes and Data Structures (Continued) ---\n\n// --- 12. List Refinements (C# specific methods) ---\n/**\n * Enhances the existing List class with more methods matching C# List functionality.\n * Note: The base `List` class already exists from the prompt's provided code.\n * We are augmenting it here with C# specific methods.\n */\n\n/*\nexport class List extends Enumerable {\n // ... existing constructor and basic Add/AddRange/Clear/RemoveAt ...\n\n // --- C# List specific methods ---\n\n /** C# PARITY: list.Find(\n*/\n\n// --- 13. IEqualityComparer (Helper class for complex comparisons) ---\n/**\n * Defines methods to support the comparison of objects for structural equality.\n * Corresponds to C# IEqualityComparer.\n * Used in Linq operations like Distinct, Union, GroupBy, and Dictionary/HashSet construction.\n */\nexport interface IEqualityComparer {\n /** Determines whether the specified objects are equal. */\n Equals(x: T, y: T): boolean;\n /** Returns a hash code for the specified object. */\n GetHashCode(obj: T): number;\n}\n\n/** Default equality comparer for primitive types (strings, numbers, booleans) */\nexport class DefaultEqualityComparer implements IEqualityComparer {\n public Equals(x: T, y: T): boolean {\n return x === y;\n }\n public GetHashCode(obj: T): number {\n // Simple hash code generation for primitives.\n // For complex objects, this would be a more complex calculation.\n if (obj === null || obj === undefined) return 0;\n switch (typeof obj) {\n case 'number':\n return obj; // Simple integer hash\n case 'string':\n let hash = 0;\n for (let i = 0; i < obj.length; i++) {\n hash = ((hash << 5) - hash) + obj.charCodeAt(i);\n hash |= 0; // Convert to 32bit integer\n }\n return hash;\n case 'boolean':\n return obj ? 1 : 0;\n default:\n // Fallback for objects, use a simple identifier or a deep equality check (not true C# hash)\n return 0; // Return 0 for non-primitive types by default in JS simulation\n }\n }\n}\n\n// --- 14. Dictionary Refinements (IEqualityComparer support) ---\n/**\n * Refines the existing Dictionary class to accept a custom IEqualityComparer.\n * Note: The base `Dictionary` class already exists.\n */\n\n\n// --- 15. HashSet Refinements (IEqualityComparer support) ---\n/**\n * Refines the existing HashSet class to accept a custom IEqualityComparer.\n * Note: The base `HashSet` class already exists.\n */\n\n/*\nexport class HashSet extends Enumerable {\n private _set: Set;\n private _comparer: IEqualityComparer;\n\n constructor(items?: T[] | Iterable, comparer?: IEqualityComparer) {\n super(items);\n this._comparer = comparer || new DefaultEqualityComparer();\n // C# behavior requires internal Set logic to use the comparer.\n // JS Set uses reference equality by default.\n this._set = new Set(this._items);\n }\n\n // For full C# compliance with complex objects as elements, a custom hash set implementation\n // using the IEqualityComparer's GetHashCode and Equals methods would be required.\n}\n*/","deleted","label",[100],"permalink","https://www.val.town/x/ziggyware/CodeUtilities/code/System.Collections.Generic9.ts","extension","actionData","errors"]