+106

src/sheets/formulas.ts

reviewed

··· 7 7 8 8 import type { CellRef, CellValue, CrossSheetResolver, NamedRangesMap, RangeArray, FormatType } from './types.js'; 9 9 import { parseSparklineArgs } from './sparkline.js'; 10 10 + import { executeQuery } from './query.js'; 10 11 11 12 // --- Tokenizer --- 12 13 type TokenTypeValue = 'NUMBER' | 'STRING' | 'BOOLEAN' | 'CELL_REF' | 'CROSS_SHEET_REF' | 'RANGE' | 'FUNCTION' | 'IDENTIFIER' | 'OPERATOR' | 'LPAREN' | 'RPAREN' | 'COMMA' | 'COLON' | 'BANG' | 'EOF'; ··· 511 512 return val; 512 513 } 513 514 } 515 515 + } 516 516 + 517 517 + // Parse LAMBDA(param1, param2, ..., body) — creates a callable closure (#88) 518 518 + // Usage: LAMBDA(x, y, x+y)(2, 3) → 5 519 519 + parseLambda(): unknown { 520 520 + this.expect(TokenType.LPAREN); 521 521 + 522 522 + // Collect parameter names and body tokens 523 523 + // All args except the last are parameter names; the last is the body expression. 524 524 + // We need to save token positions and re-parse the body with param bindings. 525 525 + const paramNames: string[] = []; 526 526 + const bodyStartPositions: number[] = []; 527 527 + 528 528 + // Read tokens to find params and body 529 529 + // Strategy: collect identifiers separated by commas, the final arg before RPAREN is the body 530 530 + // We save the start position of each arg, then retroactively determine which are params vs body 531 531 + const argStarts: number[] = []; 532 532 + let depth = 1; // already consumed LPAREN 533 533 + 534 534 + // First pass: find where each argument starts 535 535 + argStarts.push(this.pos); 536 536 + const savedPos = this.pos; 537 537 + 538 538 + // Count args by scanning tokens (tracking paren depth) 539 539 + let scanPos = this.pos; 540 540 + const argBoundaries: number[] = [scanPos]; 541 541 + while (scanPos < this.tokens.length) { 542 542 + const tok = this.tokens[scanPos]; 543 543 + if (tok.type === TokenType.LPAREN) depth++; 544 544 + else if (tok.type === TokenType.RPAREN) { 545 545 + depth--; 546 546 + if (depth === 0) break; 547 547 + } else if (tok.type === TokenType.COMMA && depth === 1) { 548 548 + argBoundaries.push(scanPos + 1); 549 549 + } 550 550 + scanPos++; 551 551 + } 552 552 + const rparenPos = scanPos; // position of closing RPAREN 553 553 + 554 554 + // All args except the last are parameter names 555 555 + for (let i = 0; i < argBoundaries.length - 1; i++) { 556 556 + const tok = this.tokens[argBoundaries[i]]; 557 557 + if (tok.type === TokenType.IDENTIFIER || tok.type === TokenType.FUNCTION || tok.type === TokenType.CELL_REF) { 558 558 + paramNames.push(String(tok.value).toLowerCase()); 559 559 + } 560 560 + } 561 561 + 562 562 + // Position parser at the start of the body (last arg) 563 563 + this.pos = argBoundaries[argBoundaries.length - 1]; 564 564 + 565 565 + // Save the body token range for deferred evaluation 566 566 + const bodyStart = this.pos; 567 567 + const bodyEnd = rparenPos; 568 568 + const bodyTokens = this.tokens.slice(bodyStart, bodyEnd); 569 569 + 570 570 + // Skip past the body and closing RPAREN 571 571 + this.pos = rparenPos; 572 572 + this.expect(TokenType.RPAREN); 573 573 + 574 574 + // Check for immediate invocation: LAMBDA(...)(<args>) 575 575 + if (this.peek().type === TokenType.LPAREN) { 576 576 + this.advance(); // consume LPAREN 577 577 + const callArgs: unknown[] = []; 578 578 + if (this.peek().type !== TokenType.RPAREN) { 579 579 + callArgs.push(this.parseFunctionArg()); 580 580 + while (this.peek().type === TokenType.COMMA) { 581 581 + this.advance(); 582 582 + callArgs.push(this.parseFunctionArg()); 583 583 + } 584 584 + } 585 585 + this.expect(TokenType.RPAREN); 586 586 + 587 587 + // Evaluate body with params bound to call args 588 588 + const prevScope = { ...this._letScope }; 589 589 + for (let i = 0; i < paramNames.length; i++) { 590 590 + this._letScope[paramNames[i]] = callArgs[i] ?? 0; 591 591 + } 592 592 + 593 593 + // Parse the body tokens 594 594 + const bodyParser = new Parser( 595 595 + [...bodyTokens, { type: TokenType.EOF, value: undefined }], 596 596 + this.getCellValue, 597 597 + this.crossSheetResolver, 598 598 + this.namedRanges, 599 599 + ); 600 600 + bodyParser._letScope = { ...this._letScope }; 601 601 + const result = bodyParser.parse(); 602 602 + 603 603 + this._letScope = prevScope; 604 604 + return result; 605 605 + } 606 606 + 607 607 + // Not immediately invoked — return a sentinel (lambdas must be invoked inline) 608 608 + return '#VALUE!'; 514 609 } 515 610 516 611 // Parse INDIRECT(ref_text) — evaluates its argument as a string, then resolves as a cell reference ··· 1401 1496 flatResult._rangeRows = uniqueRows.length; 1402 1497 flatResult._rangeCols = cols; 1403 1498 return flatResult; 1499 1499 + } 1500 1500 + 1501 1501 + // --- QUERY (#85) --- 1502 1502 + case 'QUERY': { 1503 1503 + // QUERY(data, query, [headers]) 1504 1504 + const source = Array.isArray(args[0]) ? args[0] : [args[0]]; 1505 1505 + const queryStr = String(args[1] ?? ''); 1506 1506 + const hasHeaders = args[2] !== undefined ? Boolean(args[2]) : true; 1507 1507 + const rows = (source as RangeArray)._rangeRows || source.length; 1508 1508 + const cols = (source as RangeArray)._rangeCols || 1; 1509 1509 + return executeQuery(source, rows, cols, queryStr, hasHeaders); 1404 1510 } 1405 1511 1406 1512 // --- Sparkline ---

+234

src/sheets/query.ts

reviewed

··· 1 1 + /** 2 2 + * QUERY() function (#85) 3 3 + * 4 4 + * A simplified Google-Sheets-compatible QUERY function that supports: 5 5 + * SELECT — column selection (Col1, Col2, etc.) 6 6 + * WHERE — row filtering with comparison operators 7 7 + * ORDER BY — sorting by columns (ASC/DESC) 8 8 + * LIMIT — row count limiting 9 9 + * 10 10 + * Column references use Col1, Col2, etc. (1-based). 11 11 + * Query syntax: "SELECT Col1, Col3 WHERE Col2 > 10 ORDER BY Col1 LIMIT 5" 12 12 + */ 13 13 + 14 14 + import type { RangeArray } from './types.js'; 15 15 + 16 16 + export interface QueryResult { 17 17 + data: unknown[][]; 18 18 + cols: number; 19 19 + } 20 20 + 21 21 + interface ParsedQuery { 22 22 + selectCols: number[] | null; // null = all columns 23 23 + where: WhereClause | null; 24 24 + orderBy: OrderClause | null; 25 25 + limit: number | null; 26 26 + } 27 27 + 28 28 + interface WhereClause { 29 29 + col: number; 30 30 + op: string; 31 31 + value: unknown; 32 32 + } 33 33 + 34 34 + interface OrderClause { 35 35 + col: number; 36 36 + desc: boolean; 37 37 + } 38 38 + 39 39 + /** 40 40 + * Parse a column reference like "Col1" or "Col3" to 0-based index. 41 41 + */ 42 42 + export function parseColRef(ref: string): number { 43 43 + const match = ref.match(/^Col(\d+)$/i); 44 44 + if (!match) return -1; 45 45 + return parseInt(match[1], 10) - 1; 46 46 + } 47 47 + 48 48 + /** 49 49 + * Parse a query string into structured clauses. 50 50 + */ 51 51 + export function parseQuery(query: string): ParsedQuery { 52 52 + const result: ParsedQuery = { 53 53 + selectCols: null, 54 54 + where: null, 55 55 + orderBy: null, 56 56 + limit: null, 57 57 + }; 58 58 + 59 59 + // Normalize whitespace 60 60 + let q = query.trim(); 61 61 + 62 62 + // Extract LIMIT 63 63 + const limitMatch = q.match(/\bLIMIT\s+(\d+)\s*$/i); 64 64 + if (limitMatch) { 65 65 + result.limit = parseInt(limitMatch[1], 10); 66 66 + q = q.slice(0, limitMatch.index).trim(); 67 67 + } 68 68 + 69 69 + // Extract ORDER BY 70 70 + const orderMatch = q.match(/\bORDER\s+BY\s+(Col\d+)(?:\s+(ASC|DESC))?\s*$/i); 71 71 + if (orderMatch) { 72 72 + result.orderBy = { 73 73 + col: parseColRef(orderMatch[1]), 74 74 + desc: (orderMatch[2] || '').toUpperCase() === 'DESC', 75 75 + }; 76 76 + q = q.slice(0, orderMatch.index).trim(); 77 77 + } 78 78 + 79 79 + // Extract WHERE 80 80 + const whereMatch = q.match(/\bWHERE\s+(Col\d+)\s*(>=|<=|!=|<>|>|<|=)\s*(.+?)\s*$/i); 81 81 + if (whereMatch) { 82 82 + result.where = { 83 83 + col: parseColRef(whereMatch[1]), 84 84 + op: whereMatch[2], 85 85 + value: parseValue(whereMatch[3].trim()), 86 86 + }; 87 87 + q = q.slice(0, whereMatch.index).trim(); 88 88 + } 89 89 + 90 90 + // Extract SELECT 91 91 + const selectMatch = q.match(/^SELECT\s+(.+)$/i); 92 92 + if (selectMatch) { 93 93 + const colStr = selectMatch[1].trim(); 94 94 + if (colStr !== '*') { 95 95 + result.selectCols = colStr.split(/\s*,\s*/).map(parseColRef).filter(c => c >= 0); 96 96 + } 97 97 + } 98 98 + 99 99 + return result; 100 100 + } 101 101 + 102 102 + /** 103 103 + * Parse a literal value from a WHERE clause. 104 104 + */ 105 105 + function parseValue(raw: string): unknown { 106 106 + // Quoted string 107 107 + if ((raw.startsWith("'") && raw.endsWith("'")) || (raw.startsWith('"') && raw.endsWith('"'))) { 108 108 + return raw.slice(1, -1); 109 109 + } 110 110 + // Boolean 111 111 + if (raw.toUpperCase() === 'TRUE') return true; 112 112 + if (raw.toUpperCase() === 'FALSE') return false; 113 113 + // Number 114 114 + const n = Number(raw); 115 115 + if (!isNaN(n)) return n; 116 116 + // Fallback to string 117 117 + return raw; 118 118 + } 119 119 + 120 120 + /** 121 121 + * Compare a cell value against a WHERE clause value using the given operator. 122 122 + */ 123 123 + export function compareValues(cellValue: unknown, op: string, target: unknown): boolean { 124 124 + // Normalize empty 125 125 + if (cellValue === '' || cellValue === null || cellValue === undefined) { 126 126 + if (op === '=' && (target === '' || target === null || target === undefined)) return true; 127 127 + if (op === '!=' || op === '<>') return target !== '' && target !== null && target !== undefined; 128 128 + return false; 129 129 + } 130 130 + 131 131 + // Numeric comparison 132 132 + const cv = typeof cellValue === 'number' ? cellValue : Number(cellValue); 133 133 + const tv = typeof target === 'number' ? target : Number(target); 134 134 + if (!isNaN(cv) && !isNaN(tv)) { 135 135 + switch (op) { 136 136 + case '>': return cv > tv; 137 137 + case '<': return cv < tv; 138 138 + case '>=': return cv >= tv; 139 139 + case '<=': return cv <= tv; 140 140 + case '=': return cv === tv; 141 141 + case '!=': case '<>': return cv !== tv; 142 142 + } 143 143 + } 144 144 + 145 145 + // String comparison 146 146 + const cs = String(cellValue).toLowerCase(); 147 147 + const ts = String(target).toLowerCase(); 148 148 + switch (op) { 149 149 + case '=': return cs === ts; 150 150 + case '!=': case '<>': return cs !== ts; 151 151 + case '>': return cs > ts; 152 152 + case '<': return cs < ts; 153 153 + case '>=': return cs >= ts; 154 154 + case '<=': return cs <= ts; 155 155 + } 156 156 + 157 157 + return false; 158 158 + } 159 159 + 160 160 + /** 161 161 + * Execute a QUERY against a flat range array. 162 162 + * 163 163 + * @param data Flat array of cell values (row-major) 164 164 + * @param rows Number of rows 165 165 + * @param cols Number of columns 166 166 + * @param query Query string 167 167 + * @param headers Whether first row contains headers (default: true) 168 168 + * @returns RangeArray with results or error string 169 169 + */ 170 170 + export function executeQuery( 171 171 + data: unknown[], 172 172 + rows: number, 173 173 + cols: number, 174 174 + query: string, 175 175 + headers = true, 176 176 + ): RangeArray | string { 177 177 + const parsed = parseQuery(query); 178 178 + const startRow = headers ? 1 : 0; 179 179 + 180 180 + // Build row arrays 181 181 + let rowArrays: unknown[][] = []; 182 182 + for (let r = startRow; r < rows; r++) { 183 183 + const row: unknown[] = []; 184 184 + for (let c = 0; c < cols; c++) { 185 185 + row.push(data[r * cols + c]); 186 186 + } 187 187 + rowArrays.push(row); 188 188 + } 189 189 + 190 190 + // WHERE filter 191 191 + if (parsed.where) { 192 192 + const { col, op, value } = parsed.where; 193 193 + if (col >= 0 && col < cols) { 194 194 + rowArrays = rowArrays.filter(row => compareValues(row[col], op, value)); 195 195 + } 196 196 + } 197 197 + 198 198 + // ORDER BY 199 199 + if (parsed.orderBy) { 200 200 + const { col, desc } = parsed.orderBy; 201 201 + if (col >= 0 && col < cols) { 202 202 + rowArrays.sort((a, b) => { 203 203 + const va = a[col]; 204 204 + const vb = b[col]; 205 205 + const na = typeof va === 'number' ? va : Number(va); 206 206 + const nb = typeof vb === 'number' ? vb : Number(vb); 207 207 + let cmp: number; 208 208 + if (!isNaN(na) && !isNaN(nb)) { 209 209 + cmp = na - nb; 210 210 + } else { 211 211 + cmp = String(va ?? '').localeCompare(String(vb ?? '')); 212 212 + } 213 213 + return desc ? -cmp : cmp; 214 214 + }); 215 215 + } 216 216 + } 217 217 + 218 218 + // LIMIT 219 219 + if (parsed.limit !== null && parsed.limit >= 0) { 220 220 + rowArrays = rowArrays.slice(0, parsed.limit); 221 221 + } 222 222 + 223 223 + // SELECT columns 224 224 + const selectCols = parsed.selectCols || Array.from({ length: cols }, (_, i) => i); 225 225 + const resultRows = rowArrays.map(row => selectCols.map(c => row[c] ?? '')); 226 226 + 227 227 + if (resultRows.length === 0) return '#N/A'; 228 228 + 229 229 + // Flatten to RangeArray 230 230 + const flat: RangeArray = resultRows.flat() as RangeArray; 231 231 + flat._rangeRows = resultRows.length; 232 232 + flat._rangeCols = selectCols.length; 233 233 + return flat; 234 234 + }

+186

tests/query.test.ts

reviewed

··· 1 1 + import { describe, it, expect } from 'vitest'; 2 2 + import { parseColRef, parseQuery, compareValues, executeQuery } from '../src/sheets/query.js'; 3 3 + 4 4 + describe('parseColRef', () => { 5 5 + it('parses Col1 to index 0', () => { 6 6 + expect(parseColRef('Col1')).toBe(0); 7 7 + }); 8 8 + 9 9 + it('parses Col3 to index 2', () => { 10 10 + expect(parseColRef('Col3')).toBe(2); 11 11 + }); 12 12 + 13 13 + it('is case-insensitive', () => { 14 14 + expect(parseColRef('col2')).toBe(1); 15 15 + }); 16 16 + 17 17 + it('returns -1 for invalid ref', () => { 18 18 + expect(parseColRef('A1')).toBe(-1); 19 19 + expect(parseColRef('foo')).toBe(-1); 20 20 + }); 21 21 + }); 22 22 + 23 23 + describe('parseQuery', () => { 24 24 + it('parses SELECT *', () => { 25 25 + const q = parseQuery('SELECT *'); 26 26 + expect(q.selectCols).toBeNull(); 27 27 + }); 28 28 + 29 29 + it('parses SELECT with specific columns', () => { 30 30 + const q = parseQuery('SELECT Col1, Col3'); 31 31 + expect(q.selectCols).toEqual([0, 2]); 32 32 + }); 33 33 + 34 34 + it('parses WHERE clause', () => { 35 35 + const q = parseQuery('SELECT * WHERE Col2 > 10'); 36 36 + expect(q.where).toEqual({ col: 1, op: '>', value: 10 }); 37 37 + }); 38 38 + 39 39 + it('parses WHERE with string value', () => { 40 40 + const q = parseQuery("SELECT * WHERE Col1 = 'hello'"); 41 41 + expect(q.where).toEqual({ col: 0, op: '=', value: 'hello' }); 42 42 + }); 43 43 + 44 44 + it('parses ORDER BY ascending', () => { 45 45 + const q = parseQuery('SELECT * ORDER BY Col1'); 46 46 + expect(q.orderBy).toEqual({ col: 0, desc: false }); 47 47 + }); 48 48 + 49 49 + it('parses ORDER BY descending', () => { 50 50 + const q = parseQuery('SELECT * ORDER BY Col2 DESC'); 51 51 + expect(q.orderBy).toEqual({ col: 1, desc: true }); 52 52 + }); 53 53 + 54 54 + it('parses LIMIT', () => { 55 55 + const q = parseQuery('SELECT * LIMIT 5'); 56 56 + expect(q.limit).toBe(5); 57 57 + }); 58 58 + 59 59 + it('parses full query with all clauses', () => { 60 60 + const q = parseQuery('SELECT Col1, Col3 WHERE Col2 > 5 ORDER BY Col1 DESC LIMIT 10'); 61 61 + expect(q.selectCols).toEqual([0, 2]); 62 62 + expect(q.where).toEqual({ col: 1, op: '>', value: 5 }); 63 63 + expect(q.orderBy).toEqual({ col: 0, desc: true }); 64 64 + expect(q.limit).toBe(10); 65 65 + }); 66 66 + 67 67 + it('parses != operator', () => { 68 68 + const q = parseQuery('SELECT * WHERE Col1 != 0'); 69 69 + expect(q.where!.op).toBe('!='); 70 70 + }); 71 71 + 72 72 + it('parses >= operator', () => { 73 73 + const q = parseQuery('SELECT * WHERE Col1 >= 100'); 74 74 + expect(q.where!.op).toBe('>='); 75 75 + }); 76 76 + }); 77 77 + 78 78 + describe('compareValues', () => { 79 79 + it('numeric greater than', () => { 80 80 + expect(compareValues(10, '>', 5)).toBe(true); 81 81 + expect(compareValues(3, '>', 5)).toBe(false); 82 82 + }); 83 83 + 84 84 + it('numeric less than', () => { 85 85 + expect(compareValues(3, '<', 5)).toBe(true); 86 86 + }); 87 87 + 88 88 + it('numeric equality', () => { 89 89 + expect(compareValues(5, '=', 5)).toBe(true); 90 90 + expect(compareValues(5, '=', 6)).toBe(false); 91 91 + }); 92 92 + 93 93 + it('numeric inequality', () => { 94 94 + expect(compareValues(5, '!=', 6)).toBe(true); 95 95 + expect(compareValues(5, '!=', 5)).toBe(false); 96 96 + }); 97 97 + 98 98 + it('string equality (case-insensitive)', () => { 99 99 + expect(compareValues('Hello', '=', 'hello')).toBe(true); 100 100 + }); 101 101 + 102 102 + it('string inequality', () => { 103 103 + expect(compareValues('a', '<>', 'b')).toBe(true); 104 104 + }); 105 105 + 106 106 + it('empty value handling', () => { 107 107 + expect(compareValues('', '=', '')).toBe(true); 108 108 + expect(compareValues(null, '=', '')).toBe(true); 109 109 + expect(compareValues('', '!=', 'x')).toBe(true); 110 110 + }); 111 111 + }); 112 112 + 113 113 + describe('executeQuery', () => { 114 114 + // Sample data: 4 rows x 3 cols (first row = headers) 115 115 + // Name | Age | City 116 116 + // Alice | 30 | NYC 117 117 + // Bob | 25 | LA 118 118 + // Carol | 35 | NYC 119 119 + const data = ['Name', 'Age', 'City', 'Alice', 30, 'NYC', 'Bob', 25, 'LA', 'Carol', 35, 'NYC']; 120 120 + const rows = 4; 121 121 + const cols = 3; 122 122 + 123 123 + it('SELECT * returns all data rows', () => { 124 124 + const result = executeQuery(data, rows, cols, 'SELECT *'); 125 125 + expect(Array.isArray(result)).toBe(true); 126 126 + const arr = result as unknown[]; 127 127 + expect((result as any)._rangeRows).toBe(3); 128 128 + expect((result as any)._rangeCols).toBe(3); 129 129 + expect(arr.slice(0, 3)).toEqual(['Alice', 30, 'NYC']); 130 130 + }); 131 131 + 132 132 + it('SELECT specific columns', () => { 133 133 + const result = executeQuery(data, rows, cols, 'SELECT Col1, Col3'); 134 134 + expect(Array.isArray(result)).toBe(true); 135 135 + expect((result as any)._rangeCols).toBe(2); 136 136 + const arr = [...(result as unknown[])]; 137 137 + expect(arr).toEqual(['Alice', 'NYC', 'Bob', 'LA', 'Carol', 'NYC']); 138 138 + }); 139 139 + 140 140 + it('WHERE filters rows', () => { 141 141 + const result = executeQuery(data, rows, cols, 'SELECT * WHERE Col2 > 28'); 142 142 + expect(Array.isArray(result)).toBe(true); 143 143 + expect((result as any)._rangeRows).toBe(2); 144 144 + const arr = [...(result as unknown[])]; 145 145 + expect(arr[0]).toBe('Alice'); // Age 30 146 146 + expect(arr[3]).toBe('Carol'); // Age 35 147 147 + }); 148 148 + 149 149 + it('WHERE with string match', () => { 150 150 + const result = executeQuery(data, rows, cols, "SELECT Col1 WHERE Col3 = 'NYC'"); 151 151 + expect(Array.isArray(result)).toBe(true); 152 152 + const arr = [...(result as unknown[])]; 153 153 + expect(arr).toEqual(['Alice', 'Carol']); 154 154 + }); 155 155 + 156 156 + it('ORDER BY ascending', () => { 157 157 + const result = executeQuery(data, rows, cols, 'SELECT Col1 ORDER BY Col2'); 158 158 + const arr = [...(result as unknown[])]; 159 159 + expect(arr).toEqual(['Bob', 'Alice', 'Carol']); // 25, 30, 35 160 160 + }); 161 161 + 162 162 + it('ORDER BY descending', () => { 163 163 + const result = executeQuery(data, rows, cols, 'SELECT Col1 ORDER BY Col2 DESC'); 164 164 + const arr = [...(result as unknown[])]; 165 165 + expect(arr).toEqual(['Carol', 'Alice', 'Bob']); // 35, 30, 25 166 166 + }); 167 167 + 168 168 + it('LIMIT restricts output', () => { 169 169 + const result = executeQuery(data, rows, cols, 'SELECT * LIMIT 1'); 170 170 + expect((result as any)._rangeRows).toBe(1); 171 171 + }); 172 172 + 173 173 + it('returns #N/A when no rows match', () => { 174 174 + const result = executeQuery(data, rows, cols, 'SELECT * WHERE Col2 > 100'); 175 175 + expect(result).toBe('#N/A'); 176 176 + }); 177 177 + 178 178 + it('full query: SELECT + WHERE + ORDER BY + LIMIT', () => { 179 179 + const result = executeQuery(data, rows, cols, 'SELECT Col1, Col2 WHERE Col2 >= 25 ORDER BY Col2 DESC LIMIT 2'); 180 180 + expect(Array.isArray(result)).toBe(true); 181 181 + expect((result as any)._rangeRows).toBe(2); 182 182 + expect((result as any)._rangeCols).toBe(2); 183 183 + const arr = [...(result as unknown[])]; 184 184 + expect(arr).toEqual(['Carol', 35, 'Alice', 30]); 185 185 + }); 186 186 + });