squirreling 0.10.0 → 0.10.2

package/src/expression/regexp.js

@@ -1,21 +1,20 @@
-import { argValueError } from '../validationErrors.js'
+import { argValueError } from '../validation/expressionErrors.js'
 
 /**
- * @import { SqlPrimitive } from '../types.js'
+ * @import { FunctionNode, RegExpFunction, SqlPrimitive } from '../types.js'
  */
 
 /**
  * Evaluate a regexp function
  *
  * @param {Object} options
- * @param {string} options.funcName - Uppercase function name
+ * @param {RegExpFunction} options.funcName
+ * @param {FunctionNode} options.node
  * @param {SqlPrimitive[]} options.args - Function arguments
- * @param {number} options.positionStart - Start position in SQL string for error reporting
- * @param {number} options.positionEnd - End position in SQL string for error reporting
- * @param {number} [options.rowIndex] - Row number for error reporting
+ * @param {number} options.rowIndex - Row index for error reporting
  * @returns {SqlPrimitive}
  */
-export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd, rowIndex }) {
+export function evaluateRegexpFunc({ funcName, node, args, rowIndex }) {
   if (funcName === 'REGEXP_SUBSTR') {
     const str = args[0]
     const pattern = args[1]
@@ -29,10 +28,8 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
       position = Number(args[2])
       if (!Number.isInteger(position) || position < 1) {
         throw argValueError({
-          funcName,
+          ...node,
           message: `position must be a positive integer, got ${args[2]}`,
-          positionStart,
-          positionEnd,
           hint: 'SQL uses 1-based indexing.',
           rowIndex,
         })
@@ -45,10 +42,9 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
       occurrence = Number(args[3])
       if (!Number.isInteger(occurrence) || occurrence < 1) {
         throw argValueError({
-          funcName,
+          ...node,
           message: `occurrence must be a positive integer, got ${args[3]}`,
-          positionStart,
-          positionEnd,
+          hint: 'SQL uses 1-based indexing.',
           rowIndex,
         })
       }
@@ -60,10 +56,8 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
       regex = new RegExp(patternStr, 'g')
     } catch (/** @type {any} */ error) {
       throw argValueError({
-        funcName,
+        ...node,
         message: `invalid regex pattern: ${error.message}`,
-        positionStart,
-        positionEnd,
         rowIndex,
       })
     }
@@ -99,10 +93,8 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
       position = Number(args[3])
       if (!Number.isInteger(position) || position < 1) {
         throw argValueError({
-          funcName,
+          ...node,
           message: `position must be a positive integer, got ${args[3]}`,
-          positionStart,
-          positionEnd,
           hint: 'SQL uses 1-based indexing.',
           rowIndex,
         })
@@ -115,10 +107,8 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
       occurrence = Number(args[4])
       if (!Number.isInteger(occurrence) || occurrence < 0) {
         throw argValueError({
-          funcName,
+          ...node,
           message: `occurrence must be a non-negative integer, got ${args[4]}`,
-          positionStart,
-          positionEnd,
           hint: 'Use 0 to replace all occurrences.',
           rowIndex,
         })
@@ -131,10 +121,8 @@ export function evaluateRegexpFunc({ funcName, args, positionStart, positionEnd,
       regex = new RegExp(patternStr, 'g')
     } catch (/** @type {any} */ error) {
       throw argValueError({
-        funcName,
+        ...node,
         message: `invalid regex pattern: ${error.message}`,
-        positionStart,
-        positionEnd,
         rowIndex,
       })
     }

package/src/expression/strings.js

@@ -1,30 +1,27 @@
 /**
- * @import { SqlPrimitive, StringFunc } from '../types.js'
+ * @import { FunctionNode, SqlPrimitive, StringFunc } from '../types.js'
  */
 
-import { argValueError } from '../validationErrors.js'
+import { argValueError } from '../validation/expressionErrors.js'
 
 /**
  * Evaluate a string function
  *
  * @param {Object} options
- * @param {StringFunc} options.funcName - Uppercase function name
+ * @param {StringFunc} options.funcName
+ * @param {FunctionNode} options.node
  * @param {SqlPrimitive[]} options.args - Function arguments
- * @param {number} options.positionStart - Start position for error reporting
- * @param {number} options.positionEnd - End position for error reporting
- * @param {number} [options.rowIndex] - Row index for error reporting
+ * @param {number} options.rowIndex - Row index for error reporting
  * @returns {SqlPrimitive}
  */
-export function evaluateStringFunc({ funcName, args, positionStart, positionEnd, rowIndex }) {
+export function evaluateStringFunc({ funcName, node, args, rowIndex }) {
   if (funcName === 'CONCAT') {
     // Returns NULL if any argument is NULL
     if (args.some(a => a == null)) return null
     if (args.some(a => typeof a === 'object')) {
       throw argValueError({
-        funcName: 'CONCAT',
+        ...node,
         message: 'does not support object arguments',
-        positionStart,
-        positionEnd,
         hint: 'Use CAST to convert objects to strings first.',
         rowIndex,
       })
@@ -53,10 +50,8 @@ export function evaluateStringFunc({ funcName, args, positionStart, positionEnd,
     const start = Number(args[1])
     if (!Number.isInteger(start) || start < 1) {
       throw argValueError({
-        funcName,
+        ...node,
         message: `start position must be a positive integer, got ${args[1]}`,
-        positionStart,
-        positionEnd,
         hint: 'SQL uses 1-based indexing.',
         rowIndex,
       })
@@ -67,10 +62,9 @@ export function evaluateStringFunc({ funcName, args, positionStart, positionEnd,
       const len = Number(args[2])
       if (!Number.isInteger(len) || len < 0) {
         throw argValueError({
-          funcName,
+          ...node,
           message: `length must be a non-negative integer, got ${args[2]}`,
-          positionStart,
-          positionEnd,
+          hint: 'SQL uses 1-based indexing.',
           rowIndex,
         })
       }
@@ -97,10 +91,9 @@ export function evaluateStringFunc({ funcName, args, positionStart, positionEnd,
     const len = Number(n)
     if (!Number.isInteger(len) || len < 0) {
       throw argValueError({
-        funcName,
+        ...node,
         message: `length must be a non-negative integer, got ${n}`,
-        positionStart,
-        positionEnd,
+        hint: 'SQL uses 1-based indexing.',
         rowIndex,
       })
     }
@@ -113,10 +106,9 @@ export function evaluateStringFunc({ funcName, args, positionStart, positionEnd,
     const len = Number(n)
     if (!Number.isInteger(len) || len < 0) {
       throw argValueError({
-        funcName,
+        ...node,
         message: `length must be a non-negative integer, got ${n}`,
-        positionStart,
-        positionEnd,
+        hint: 'SQL uses 1-based indexing.',
         rowIndex,
       })
     }

package/src/index.d.ts

@@ -55,6 +55,7 @@ export function parseSql(options: ParseSqlOptions): SelectStatement
  * @param options
  * @param options.query - SQL query string or parsed SelectStatement
  * @param options.functions - user-defined functions available in the SQL context
+ * @param options.tables - optional table metadata for planning
  * @returns the root of the query plan tree
  */
 export function planSql(options: PlanSqlOptions): QueryPlan

package/src/parse/comparison.js

@@ -1,5 +1,5 @@
-import { syntaxError } from '../parseErrors.js'
-import { isBinaryOp } from '../validation.js'
+import { isBinaryOp } from '../validation/functions.js'
+import { syntaxError } from '../validation/parseErrors.js'
 import { parseAdditive, parseExpression, parseSubquery } from './expression.js'
 import { consume, current, expect, match, peekToken } from './state.js'
 

package/src/parse/expression.js

@@ -3,8 +3,8 @@ import {
   missingClauseError,
   syntaxError,
   unknownFunctionError,
-} from '../parseErrors.js'
-import { RESERVED_KEYWORDS, isExtractField, isIntervalUnit, isKnownFunction } from '../validation.js'
+} from '../validation/parseErrors.js'
+import { RESERVED_KEYWORDS, isCastType, isExtractField, isIntervalUnit, isKnownFunction } from '../validation/functions.js'
 import { parseComparison } from './comparison.js'
 import { parseFunctionCall } from './functions.js'
 import { parseSelectInternal } from './parse.js'
@@ -60,11 +60,19 @@ export function parsePrimary(state) {
       const expr = parseExpression(state)
       expect(state, 'keyword', 'AS')
       const typeTok = expectIdentifier(state)
+      const toType = typeTok.value.toUpperCase()
+      if (!isCastType(toType)) {
+        throw syntaxError({
+          ...typeTok,
+          expected: 'cast type (STRING, INT, BIGINT, FLOAT, BOOL)',
+          received: `"${typeTok.value}"`,
+        })
+      }
       expect(state, 'paren', ')')
       return {
         type: 'cast',
         expr,
-        toType: typeTok.value,
+        toType,
         positionStart,
         positionEnd: state.lastPos,
       }
@@ -75,13 +83,11 @@ export function parsePrimary(state) {
       consume(state) // EXTRACT
       consume(state) // '('
       const fieldTok = current(state)
-      const isValidType = fieldTok.type === 'keyword' || fieldTok.type === 'identifier'
-      if (!isValidType || !isExtractField(fieldTok.value)) {
+      if (!isExtractField(fieldTok.value)) {
         throw syntaxError({
+          ...fieldTok,
           expected: 'extract field (YEAR, MONTH, DAY, HOUR, MINUTE, SECOND, DOW, EPOCH)',
           received: `"${fieldTok.value}"`,
-          positionStart: fieldTok.positionStart,
-          positionEnd: fieldTok.positionEnd,
         })
       }
       consume(state) // field
@@ -90,7 +96,7 @@ export function parsePrimary(state) {
       expect(state, 'paren', ')')
       return {
         type: 'function',
-        name: 'EXTRACT',
+        funcName: 'EXTRACT',
         args: [
           { type: 'literal', value: fieldTok.value, positionStart: fieldTok.positionStart, positionEnd: fieldTok.positionEnd },
           expr,
@@ -123,7 +129,7 @@ export function parsePrimary(state) {
       consume(state)
       return {
         type: 'function',
-        name: tok.value,
+        funcName: tok.value,
         args: [],
         positionStart,
         positionEnd: state.lastPos,
@@ -217,7 +223,12 @@ export function parsePrimary(state) {
         const condition = parseExpression(state)
         expect(state, 'keyword', 'THEN')
         const result = parseExpression(state)
-        whenClauses.push({ condition, result })
+        whenClauses.push({
+          condition,
+          result,
+          positionStart: condition.positionStart,
+          positionEnd: result.positionEnd,
+        })
       }
 
       if (whenClauses.length === 0) {

package/src/parse/functions.js

@@ -1,5 +1,5 @@
-import { ParseError, argCountParseError, syntaxError } from '../parseErrors.js'
-import { isAggregateFunc, validateFunctionArgCount } from '../validation.js'
+import { isAggregateFunc, validateFunctionArgCount } from '../validation/functions.js'
+import { ParseError, syntaxError } from '../validation/parseErrors.js'
 import { parseExpression } from './expression.js'
 import { consume, current, expect, match } from './state.js'
 
@@ -17,11 +17,13 @@ import { consume, current, expect, match } from './state.js'
  * @returns {ExprNode}
  */
 export function parseFunctionCall(state, funcName, positionStart) {
-  consume(state) // '('
+  const funcNameUpper = funcName.toUpperCase()
+  consume(state) // '(' checked by caller
 
   /** @type {ExprNode[]} */
   const args = []
-  let distinct = false
+  /** @type {true | undefined} */
+  let distinct
 
   // Check for DISTINCT or ALL keyword (for aggregate functions like COUNT(DISTINCT x))
   if (current(state).type === 'keyword' && current(state).value === 'DISTINCT') {
@@ -48,14 +50,12 @@ export function parseFunctionCall(state, funcName, positionStart) {
       if (!match(state, 'comma')) break
     }
   }
-
   expect(state, 'paren', ')')
 
   // Check for FILTER clause (only valid for aggregate functions)
   /** @type {ExprNode | undefined} */
   let filter
   if (current(state).type === 'keyword' && current(state).value === 'FILTER') {
-    const funcNameUpper = funcName.toUpperCase()
     if (!isAggregateFunc(funcNameUpper)) {
       throw syntaxError({
         expected: 'aggregate function for FILTER clause',
@@ -70,44 +70,35 @@ export function parseFunctionCall(state, funcName, positionStart) {
     filter = parseExpression(state)
     expect(state, 'paren', ')')
   }
+  const positionEnd = state.lastPos
 
   // Validate star argument at parse time (only COUNT supports *)
-  const funcNameUpper = funcName.toUpperCase()
   const hasStar = args.length === 1 && args[0].type === 'star'
-  if (hasStar && isAggregateFunc(funcNameUpper) && funcNameUpper !== 'COUNT') {
+  if (hasStar && funcNameUpper !== 'COUNT') {
     throw new ParseError({
       message: `${funcName} cannot be applied to "*"`,
       positionStart,
-      positionEnd: state.lastPos,
+      positionEnd,
     })
   }
   if (hasStar && distinct) {
     throw new ParseError({
       message: 'COUNT(DISTINCT *) is not allowed',
       positionStart,
-      positionEnd: state.lastPos,
+      positionEnd,
     })
   }
 
   // Validate argument count at parse time
-  const validation = validateFunctionArgCount(funcNameUpper, args.length, state.functions)
-  if (!validation.valid) {
-    throw argCountParseError({
-      funcName,
-      expected: validation.expected,
-      received: args.length,
-      positionStart,
-      positionEnd: state.lastPos,
-    })
-  }
+  validateFunctionArgCount(funcNameUpper, args.length, positionStart, positionEnd, state.functions)
 
   return {
     type: 'function',
-    name: funcName,
+    funcName,
     args,
-    distinct: distinct || undefined,
+    distinct,
     filter,
     positionStart,
-    positionEnd: state.lastPos,
+    positionEnd,
   }
 }

package/src/parse/joins.js

@@ -1,7 +1,7 @@
+import { expectNoAggregate } from '../validation/aggregates.js'
 import { parseExpression } from './expression.js'
 import { parseTableAlias } from './parse.js'
 import { consume, current, expect, expectIdentifier, match } from './state.js'
-import { expectNoAggregate } from '../validation.js'
 
 /**
  * @import { ExprNode, JoinClause, JoinType, ParserState } from '../types.js'
@@ -59,7 +59,8 @@ export function parseJoins(state) {
     }
 
     // Parse table name and optional alias
-    const tableName = expectIdentifier(state).value
+    const tableTok = expectIdentifier(state)
+    const tableName = tableTok.value
     const tableAlias = parseTableAlias(state)
 
     // Parse ON condition (not for POSITIONAL joins)
@@ -76,6 +77,8 @@ export function parseJoins(state) {
       table: tableName,
       alias: tableAlias,
       on: condition,
+      positionStart: tableTok.positionStart,
+      positionEnd: tableTok.positionEnd,
     })
   }
 

package/src/parse/parse.js

@@ -1,9 +1,10 @@
+import { expectNoAggregate, findAggregate } from '../validation/aggregates.js'
+import { RESERVED_AFTER_COLUMN, RESERVED_AFTER_TABLE } from '../validation/functions.js'
+import { duplicateCTEError } from '../validation/parseErrors.js'
 import { parseExpression } from './expression.js'
 import { parseJoins } from './joins.js'
 import { consume, current, expect, expectIdentifier, match, parseError, peekToken } from './state.js'
 import { tokenizeSql } from './tokenize.js'
-import { duplicateCTEError } from '../parseErrors.js'
-import { RESERVED_AFTER_COLUMN, RESERVED_AFTER_TABLE, expectNoAggregate, findAggregate } from '../validation.js'
 
 /**
  * @import { CTEDefinition, ExprNode, FromSubquery, FromTable, OrderByItem, ParseSqlOptions, ParserState, SelectStatement, SelectColumn, WithClause } from '../types.js'
@@ -223,9 +224,9 @@ export function parseSelectInternal(state) {
     from = parseFromSubquery(state)
   } else {
     // Simple table name: SELECT * FROM users
-    const table = expectIdentifier(state).value
+    const tableTok = expectIdentifier(state)
     const alias = parseTableAlias(state)
-    from = { kind: 'table', table, alias }
+    from = { kind: 'table', table: tableTok.value, alias, positionStart: tableTok.positionStart, positionEnd: tableTok.positionEnd }
   }
 
   // Parse JOIN clauses

package/src/parse/state.js

@@ -1,8 +1,8 @@
-import { syntaxError } from '../parseErrors.js'
+import { syntaxError } from '../validation/parseErrors.js'
 
 /**
  * @import { ParserState, Token, TokenType } from '../types.js'
- * @import { ParseError } from '../parseErrors.js'
+ * @import { ParseError } from '../validation/parseErrors.js'
  */
 
 /**

package/src/parse/tokenize.js

@@ -1,8 +1,4 @@
-import {
-  invalidLiteralError,
-  unexpectedCharError,
-  unterminatedError,
-} from '../parseErrors.js'
+import { invalidLiteralError, unexpectedCharError, unterminatedError } from '../validation/parseErrors.js'
 
 /**
  * @import { Token } from '../types.d.ts'
@@ -354,10 +350,7 @@ export function tokenizeSql(sql) {
       continue
     }
 
-    if (tokens.length === 0) {
-      throw unexpectedCharError({ char: ch, positionStart: pos, expectsSelect: true })
-    }
-    throw unexpectedCharError({ char: ch, positionStart: pos })
+    throw unexpectedCharError({ char: ch, positionStart: pos, expectsSelect: !tokens.length })
   }
 
   tokens.push({

package/src/parse/types.d.ts

@@ -1,4 +1,4 @@
-import { UserDefinedFunction } from '../types.js'
+import type { UserDefinedFunction } from '../types.js'
 
 export interface ParserState {
   tokens: Token[]

package/src/plan/plan.js

@@ -1,9 +1,10 @@
 import { parseSql } from '../parse/parse.js'
-import { findAggregate } from '../validation.js'
+import { findAggregate } from '../validation/aggregates.js'
+import { columnNotFoundError, tableNotFoundError } from '../validation/planErrors.js'
 import { extractColumns } from './columns.js'
 
 /**
- * @import { ExprNode, DerivedColumn, JoinClause, PlanSqlOptions, ScanOptions, SelectColumn, SelectStatement } from '../types.js'
+ * @import { AsyncDataSource, ExprNode, DerivedColumn, JoinClause, PlanSqlOptions, ScanOptions, SelectColumn, SelectStatement } from '../types.js'
  * @import { QueryPlan } from './types.d.ts'
  */
 
@@ -14,7 +15,7 @@ import { extractColumns } from './columns.js'
  * @param {PlanSqlOptions} options
  * @returns {QueryPlan} the root of the query plan tree
  */
-export function planSql({ query, functions }) {
+export function planSql({ query, functions, tables }) {
   const select = typeof query === 'string' ? parseSql({ query, functions }) : query
 
   // Build CTE plans in order (each CTE can reference preceding CTEs)
@@ -22,12 +23,12 @@ export function planSql({ query, functions }) {
   const ctePlans = new Map()
   if (select.with) {
     for (const cte of select.with.ctes) {
-      const ctePlan = planSelect({ select: cte.query, ctePlans })
+      const ctePlan = planSelect({ select: cte.query, ctePlans, tables })
       ctePlans.set(cte.name.toLowerCase(), ctePlan)
     }
   }
 
-  return planSelect({ select, ctePlans })
+  return planSelect({ select, ctePlans, tables })
 }
 
 /**
@@ -36,9 +37,10 @@ export function planSql({ query, functions }) {
  * @param {object} options
  * @param {SelectStatement} options.select
  * @param {Map<string, QueryPlan>} options.ctePlans
+ * @param {Record<string, AsyncDataSource>} [options.tables]
  * @returns {QueryPlan}
  */
-function planSelect({ select, ctePlans }) {
+function planSelect({ select, ctePlans, tables }) {
   // Check for aggregation
   const hasAggregate = select.columns.some(col =>
     col.kind === 'derived' && findAggregate(col.expr)
@@ -67,11 +69,11 @@ function planSelect({ select, ctePlans }) {
 
   // Start with the data source (FROM clause)
   /** @type {QueryPlan} */
-  let plan = planFrom({ select, ctePlans, hints })
+  let plan = planFrom({ select, ctePlans, hints, tables })
 
   // Add JOINs
   if (select.joins.length) {
-    plan = planJoin({ left: plan, joins: select.joins, leftTable: sourceAlias, ctePlans, perTableColumns })
+    plan = planJoin({ left: plan, joins: select.joins, leftTable: sourceAlias, ctePlans, perTableColumns, tables })
   }
 
   // Whether FROM resolved to our own direct table scan
@@ -153,20 +155,22 @@ function planSelect({ select, ctePlans }) {
  * @param {SelectStatement} options.select
  * @param {Map<string, QueryPlan>} options.ctePlans
  * @param {ScanOptions} options.hints
+ * @param {Record<string, AsyncDataSource>} [options.tables]
  * @returns {QueryPlan}
  */
-function planFrom({ select, ctePlans, hints }) {
+function planFrom({ select, ctePlans, hints, tables }) {
   if (select.from.kind === 'table') {
     const ctePlan = ctePlans.get(select.from.table.toLowerCase())
     if (ctePlan) {
       return ctePlan
     }
+    validateScan({ ...select.from, hints, tables })
     return { type: 'Scan', table: select.from.table, hints }
   } else {
     if (select.from.query.with) {
       throw new Error('WITH clause is not supported inside subqueries')
     }
-    return planSelect({ select: select.from.query, ctePlans })
+    return planSelect({ select: select.from.query, ctePlans, tables })
   }
 }
 
@@ -177,9 +181,10 @@ function planFrom({ select, ctePlans, hints }) {
  * @param {string} options.leftTable - name/alias of the left table
  * @param {Map<string, QueryPlan>} options.ctePlans
  * @param {Map<string, string[] | undefined>} options.perTableColumns
+ * @param {Record<string, AsyncDataSource>} [options.tables]
  * @returns {QueryPlan}
  */
-function planJoin({ left, joins, leftTable, ctePlans, perTableColumns }) {
+function planJoin({ left, joins, leftTable, ctePlans, perTableColumns, tables }) {
   let plan = left
   let currentLeftTable = leftTable
 
@@ -191,6 +196,7 @@ function planJoin({ left, joins, leftTable, ctePlans, perTableColumns }) {
     const rightHints = {}
     if (!ctePlan) {
       rightHints.columns = perTableColumns.get(rightTable)
+      validateScan({ ...join, hints: rightHints, tables })
     }
     /** @type {QueryPlan} */
     const rightScan = ctePlan ?? { type: 'Scan', table: join.table, hints: rightHints }
@@ -313,6 +319,33 @@ function extractSimpleJoinKeys({ condition, leftTable, rightTable }) {
   return { leftKey: left, rightKey: right }
 }
 
+/**
+ * Validates that a table exists and requested columns are available.
+ *
+ * @param {object} options
+ * @param {string} options.table
+ * @param {ScanOptions} options.hints
+ * @param {Record<string, AsyncDataSource>} [options.tables]
+ * @param {number} options.positionStart
+ * @param {number} options.positionEnd
+ */
+function validateScan({ table, hints, tables, positionStart, positionEnd }) {
+  if (!tables) return
+  const resolved = tables[table]
+  if (!resolved) {
+    throw tableNotFoundError({ table, tables, positionStart, positionEnd })
+  }
+  const missingColumn = hints.columns?.find(col => !resolved.columns.includes(col))
+  if (missingColumn) {
+    throw columnNotFoundError({
+      columnName: missingColumn,
+      availableColumns: resolved.columns,
+      positionStart,
+      positionEnd,
+    })
+  }
+}
+
 /**
  * Checks if every SELECT column is a plain COUNT(*).
  *
@@ -324,7 +357,7 @@ function isAllCountStar(columns) {
   return columns.every(col =>
     col.kind === 'derived' &&
     col.expr.type === 'function' &&
-    col.expr.name.toUpperCase() === 'COUNT' &&
+    col.expr.funcName.toUpperCase() === 'COUNT' &&
     col.expr.args.length === 1 &&
     col.expr.args[0].type === 'star' &&
     !col.expr.distinct &&

package/src/spatial/bbox.js

@@ -28,7 +28,7 @@ export function bboxOverlap(a, b) {
  * @param {SimpleGeometry} geom
  * @returns {BBox}
  */
-function bbox(geom) {
+export function bbox(geom) {
   let b = bboxCache.get(geom)
   if (b) return b
   if (geom.type === 'Point') {