# Collapsible Code Editor: Brace Matching and Toggle You are building a feature for a code editor. The editor holds source code written in a curly-brace language (like C++ or Java) that uses `{` to open a block and `}` to close it. The document is represented as a list of lines, one string per line. To simplify parsing, you may assume: - A brace, if present on a line, appears **only as the last character of that line**. At most one brace appears per line. - The input is **always valid**: braces are balanced and properly nested (every `{` has a matching `}` that closes after it, and pairs never partially overlap). - Lines may also contain no brace at all (plain code or text). Implement the following in two parts. ## Part 1 — Match the braces Write a function that takes the list of lines and returns the matching between every opening brace and its corresponding closing brace, keyed by line index. ``` matchBraces(lines: List[str]) -> Dict[int, int] ``` - The returned mapping has one entry per brace pair. - The **key** is the 0-based line index of a line ending in `{`. - The **value** is the 0-based line index of the matching line ending in `}`. ### Example ``` Input lines: 0: "class A {" 1: " void f() {" 2: " doWork();" 3: " }" 4: " int x;" 5: "}" Output: {0: 5, 1: 3} ``` Line 0's `{` matches line 5's `}`; line 1's `{` matches line 3's `}`. ## Part 2 — Toggle collapse / expand Add an interactive collapse feature. The editor starts with every block **expanded** (fully shown). Support two operations: ``` toggle(openLineIndex: int) -> None # flip the collapsed state of the brace pair whose '{' is on openLineIndex getText() -> List[str] # return the lines currently displayed ``` Collapsing semantics: - `toggle(i)` flips the collapsed/expanded state of the single brace pair whose opening `{` is on line `i`. (You may assume `i` is the index of a line that ends in `{`.) - When a brace pair is **collapsed**, the entire range from its `{` line through its matching `}` line is shown as one single line whose text is the original opening line with `" ... }"` appended. - For the example above, collapsing the pair on line 1 would display line 1 as `" void f() { ... }"`, and lines 2 and 3 would not be shown at all. - When a brace pair is **expanded** (the default), its opening and closing lines and the content between them are shown normally, subject to the collapse state of any nested pairs. Independence of nesting — this is the key requirement: - Each brace pair has its **own independent** collapsed/expanded state. - Collapsing or expanding an outer pair must **not** change the stored state of any pair nested inside it. - Concretely: if an inner pair is collapsed and you then collapse the outer pair, the outer pair hides everything (so you only see the outer one-line summary). If you later expand the outer pair, the inner pair is revealed **still in its collapsed state** — not re-expanded. `getText()` must reflect the current collapsed/expanded state of all pairs, rendering only the lines that are visible from the outside in. ### Example of independent state Starting from the example document, suppose the following calls happen in order: ``` toggle(1) # collapse the inner pair (lines 1-3) getText() -> 0: "class A {" 1: " void f() { ... }" 2: " int x;" # this is original line 4 3: "}" # this is original line 5 toggle(0) # collapse the outer pair (lines 0-5) getText() -> 0: "class A { ... }" toggle(0) # expand the outer pair again getText() -> 0: "class A {" 1: " void f() { ... }" # inner pair is STILL collapsed 2: " int x;" 3: "}" ``` ## Requirements - `matchBraces` should run in a single pass over the lines. - `getText()` should produce the correct visible rendering for any combination of collapsed/expanded pairs, respecting nesting independence. - Index handling must be precise: when a pair is collapsed, every line strictly between its `{` and `}` (inclusive of the `}` line) is suppressed and replaced by the single summary line.