conjure-js 0.0.13 → 0.0.14

package/src/core/printer.ts

@@ -1,52 +1,66 @@
 import { EvaluationError } from './errors'
 import type { CljCons, CljLazySeq } from './types'
-import { valueKeywords, type CljMultiMethod, type CljValue, type EvaluationContext } from './types'
+import {
+  type CljMultiMethod,
+  type CljValue,
+  type EvaluationContext,
+} from './types'
 import { derefValue } from './env'
+import { specialFormKeywords, valueKeywords } from './keywords.ts'
+import { is } from './assertions.ts'
+import { v } from './factories.ts'
 
 const LAZY_PRINT_CAP = 100
 
 /** Realize a lazy-seq (local copy to avoid circular dep with transformations). */
 function realizeLazy(ls: CljLazySeq): CljValue {
   let current: CljValue = ls
-  while (current.kind === 'lazy-seq') {
+  while (is.lazySeq(current)) {
     const lazy = current as CljLazySeq
-    if (lazy.realized) { current = lazy.value!; continue }
+    if (lazy.realized) {
+      current = lazy.value!
+      continue
+    }
     if (lazy.thunk) {
       lazy.value = lazy.thunk()
       lazy.thunk = null
       lazy.realized = true
       current = lazy.value!
     } else {
-      return { kind: 'nil', value: null }
+      return v.nil()
     }
   }
   return current
 }
 
 /** Walk a lazy/cons chain collecting up to `limit` elements for printing. */
-function collectSeqElements(value: CljValue, limit: number, depth: number): { items: string[]; truncated: boolean } {
+function collectSeqElements(
+  value: CljValue,
+  limit: number,
+  depth: number
+): { items: string[]; truncated: boolean } {
   const items: string[] = []
   let current = value
   while (items.length < limit) {
-    if (current.kind === 'nil') break
-    if (current.kind === 'lazy-seq') {
+    if (is.nil(current)) break
+    if (is.lazySeq(current)) {
       current = realizeLazy(current as CljLazySeq)
       continue
     }
-    if (current.kind === 'cons') {
+    if (is.cons(current)) {
       const c = current as CljCons
       items.push(printString(c.head, depth + 1))
       current = c.tail
       continue
     }
-    if (current.kind === 'list') {
+    if (is.list(current)) {
       for (const v of current.value) {
         if (items.length >= limit) break
         items.push(printString(v, depth + 1))
       }
       break
     }
-    if (current.kind === 'vector') {
+    if (is.vector(current)) {
       for (const v of current.value) {
         if (items.length >= limit) break
         items.push(printString(v, depth + 1))
@@ -69,7 +83,9 @@ export interface PrintContext {
 
 let _printCtx: PrintContext = { printLength: null, printLevel: null }
 
-export function getPrintContext(): PrintContext { return _printCtx }
+export function getPrintContext(): PrintContext {
+  return _printCtx
+}
 
 export function withPrintContext<T>(ctx: PrintContext, fn: () => T): T {
   const prev = _printCtx
@@ -93,8 +109,8 @@ export function buildPrintContext(ctx: EvaluationContext): PrintContext {
   const len = lenVar ? derefValue(lenVar) : undefined
   const level = lvlVar ? derefValue(lvlVar) : undefined
   return {
-    printLength: len?.kind === 'number' ? len.value : null,
-    printLevel: level?.kind === 'number' ? level.value : null,
+    printLength: len && is.number(len) ? len.value : null,
+    printLevel: level && is.number(level) ? level.value : null,
   }
 }
 
@@ -102,10 +118,14 @@ export function printString(value: CljValue, _depth = 0): string {
   const { printLevel } = _printCtx
   if (printLevel !== null && _depth >= printLevel) {
     if (
-      value.kind === 'list' || value.kind === 'vector' ||
-      value.kind === 'map' || value.kind === 'set' ||
-      value.kind === 'cons' || value.kind === 'lazy-seq'
-    ) return '#'
+      is.list(value) ||
+      is.vector(value) ||
+      is.map(value) ||
+      is.set(value) ||
+      is.cons(value) ||
+      is.lazySeq(value)
+    )
+      return '#'
   }
   return printStringImpl(value, _depth)
 }
@@ -148,33 +168,41 @@ function printStringImpl(value: CljValue, depth: number): string {
       return `${value.name}`
     case valueKeywords.list: {
       const { printLength } = _printCtx
-      const items = printLength !== null ? value.value.slice(0, printLength) : value.value
-      const suffix = printLength !== null && value.value.length > printLength ? ' ...' : ''
-      return `(${items.map(v => printString(v, depth + 1)).join(' ')}${suffix})`
+      const items =
+        printLength !== null ? value.value.slice(0, printLength) : value.value
+      const suffix =
+        printLength !== null && value.value.length > printLength ? ' ...' : ''
+      return `(${items.map((v) => printString(v, depth + 1)).join(' ')}${suffix})`
     }
     case valueKeywords.vector: {
       const { printLength } = _printCtx
-      const items = printLength !== null ? value.value.slice(0, printLength) : value.value
-      const suffix = printLength !== null && value.value.length > printLength ? ' ...' : ''
-      return `[${items.map(v => printString(v, depth + 1)).join(' ')}${suffix}]`
+      const items =
+        printLength !== null ? value.value.slice(0, printLength) : value.value
+      const suffix =
+        printLength !== null && value.value.length > printLength ? ' ...' : ''
+      return `[${items.map((v) => printString(v, depth + 1)).join(' ')}${suffix}]`
     }
     case valueKeywords.map: {
       const { printLength } = _printCtx
-      const entries = printLength !== null ? value.entries.slice(0, printLength) : value.entries
-      const suffix = printLength !== null && value.entries.length > printLength ? ' ...' : ''
+      const entries =
+        printLength !== null
+          ? value.entries.slice(0, printLength)
+          : value.entries
+      const suffix =
+        printLength !== null && value.entries.length > printLength ? ' ...' : ''
       return `{${entries.map(([key, v]) => `${printString(key, depth + 1)} ${printString(v, depth + 1)}`).join(' ')}${suffix}}`
     }
     case valueKeywords.function: {
       if (value.arities.length === 1) {
         const a = value.arities[0]
         const params = a.restParam
-          ? [...a.params, { kind: 'symbol' as const, name: '&' }, a.restParam]
+          ? [...a.params, v.symbol('&'), a.restParam]
           : a.params
         return `(fn [${params.map(printString).join(' ')}] ${a.body.map(printString).join(' ')})`
       }
       const clauses = value.arities.map((a) => {
         const params = a.restParam
-          ? [...a.params, { kind: 'symbol' as const, name: '&' }, a.restParam]
+          ? [...a.params, v.symbol('&'), a.restParam]
           : a.params
         return `([${params.map(printString).join(' ')}] ${a.body.map(printString).join(' ')})`
       })
@@ -199,12 +227,15 @@ function printStringImpl(value: CljValue, depth: number): string {
       return `#'${value.ns}/${value.name}`
     case valueKeywords.set: {
       const { printLength } = _printCtx
-      const items = printLength !== null ? value.values.slice(0, printLength) : value.values
-      const suffix = printLength !== null && value.values.length > printLength ? ' ...' : ''
-      return `#{${items.map(v => printString(v, depth + 1)).join(' ')}${suffix}}`
+      const items =
+        printLength !== null ? value.values.slice(0, printLength) : value.values
+      const suffix =
+        printLength !== null && value.values.length > printLength ? ' ...' : ''
+      return `#{${items.map((v) => printString(v, depth + 1)).join(' ')}${suffix}}`
     }
     case valueKeywords.delay:
-      if (value.realized) return `#<Delay @${printString(value.value!, depth + 1)}>`
+      if (value.realized)
+        return `#<Delay @${printString(value.value!, depth + 1)}>`
       return '#<Delay pending>'
     case valueKeywords.lazySeq:
     case valueKeywords.cons: {
@@ -236,7 +267,9 @@ function printStringImpl(value: CljValue, depth: number): string {
       } else if (raw instanceof Promise) {
         typeName = 'Promise'
       } else {
-        typeName = (raw as { constructor?: { name?: string } }).constructor?.name ?? 'Object'
+        typeName =
+          (raw as { constructor?: { name?: string } }).constructor?.name ??
+          'Object'
       }
       return `#<js ${typeName}>`
     }
@@ -257,22 +290,59 @@ export function joinLines(lines: string[]): string {
 // Remaining args are indented 2 spaces from the opening paren.
 const BODY_FORM_HEADER_COUNT: Record<string, number> = {
   // 0-header: entire body is indented
-  do: 0, try: 0, and: 0, or: 0, cond: 0, '->': 0, '->>': 0, 'some->': 0, 'some->>': 0,
+  do: 0,
+  try: 0,
+  and: 0,
+  or: 0,
+  cond: 0,
+  '->': 0,
+  '->>': 0,
+  'some->': 0,
+  'some->>': 0,
   // 1-header: one leading arg kept on first line (condition / binding vec / value)
-  when: 1, 'when-not': 1, 'when-let': 1, 'when-some': 1, 'when-first': 1,
-  if: 1, 'if-not': 1, 'if-let': 1, 'if-some': 1, while: 1,
-  let: 1, loop: 1, binding: 1, 'with-open': 1, 'with-local-vars': 1, locking: 1,
-  fn: 1, 'fn*': 1,
-  def: 1, defonce: 1, ns: 1,
-  doseq: 1, dotimes: 1, for: 1,
-  case: 1, 'cond->': 1, 'cond->>': 1,
+  when: 1,
+  'when-not': 1,
+  'when-let': 1,
+  'when-some': 1,
+  'when-first': 1,
+  if: 1,
+  'if-not': 1,
+  'if-let': 1,
+  'if-some': 1,
+  while: 1,
+  let: 1,
+  loop: 1,
+  binding: 1,
+  'with-open': 1,
+  'with-local-vars': 1,
+  locking: 1,
+  fn: 1,
+  'fn*': 1,
+  def: 1,
+  defonce: 1,
+  ns: 1,
+  doseq: 1,
+  dotimes: 1,
+  for: 1,
+  case: 1,
+  'cond->': 1,
+  'cond->>': 1,
   // 2-header: name + params/dispatch on first line
-  defn: 2, 'defn-': 2, defmacro: 2, defmethod: 2,
+  defn: 2,
+  'defn-': 2,
+  defmacro: 2,
+  defmethod: 2,
 }
 
 // Forms whose first header arg (binding vector) should be printed as pairs.
 const BINDING_FORMS = new Set([
-  'let', 'loop', 'binding', 'with-open', 'for', 'doseq', 'dotimes',
+  specialFormKeywords.let,
+  specialFormKeywords.loop,
+  specialFormKeywords.binding,
+  'with-open',
+  'for',
+  'doseq',
+  'dotimes',
 ])
 
 // Forms whose body args are pairs (test expr, test expr, ...).
@@ -330,19 +400,29 @@ function ppList(items: CljValue[], col: number, maxWidth: number): string {
     for (let i = 0; i < headerArgs.length; i++) {
       const arg = headerArgs[i]
       const argCol = curCol + 1
-      const isPairVec = BINDING_FORMS.has(name) && i === 0 && arg.kind === valueKeywords.vector
+      const isPairVec =
+        BINDING_FORMS.has(name) && i === 0 && arg.kind === valueKeywords.vector
       const argStr = isPairVec
-        ? ppVec((arg as Extract<CljValue, { kind: 'vector' }>).value, argCol, maxWidth, true)
+        ? ppVec(
+            (arg as Extract<CljValue, { kind: 'vector' }>).value,
+            argCol,
+            maxWidth,
+            true
+          )
         : pp(arg, argCol, maxWidth)
       result += ' ' + argStr
-      curCol = argStr.includes('\n') ? lastLineLen(argStr) : argCol + argStr.length - 1
+      curCol = argStr.includes('\n')
+        ? lastLineLen(argStr)
+        : argCol + argStr.length - 1
     }
 
     if (bodyArgs.length === 0) return result + ')'
 
     const bodyStr = PAIR_BODY_FORMS.has(name)
       ? ppPairs(bodyArgs, bodyIndent, maxWidth)
-      : bodyArgs.map(a => sp(bodyIndent) + pp(a, bodyIndent, maxWidth)).join('\n')
+      : bodyArgs
+          .map((a) => sp(bodyIndent) + pp(a, bodyIndent, maxWidth))
+          .join('\n')
 
     return result + '\n' + bodyStr + ')'
   }
@@ -359,18 +439,37 @@ function ppList(items: CljValue[], col: number, maxWidth: number): string {
   // For short head names: align subsequent args with the first arg.
   // For long head names: fall back to 2-space indent for all args.
   const argIndent = headStr.length <= 10 ? firstArgCol : col + 2
-  const argStrs = args.map(a => pp(a, argIndent, maxWidth))
+  const argStrs = args.map((a) => pp(a, argIndent, maxWidth))
 
   if (argIndent === firstArgCol) {
     return (
-      '(' + headStr + ' ' + argStrs[0] + '\n' +
-      argStrs.slice(1).map(s => sp(argIndent) + s).join('\n') + ')'
+      '(' +
+      headStr +
+      ' ' +
+      argStrs[0] +
+      '\n' +
+      argStrs
+        .slice(1)
+        .map((s) => sp(argIndent) + s)
+        .join('\n') +
+      ')'
     )
   }
-  return '(' + headStr + '\n' + argStrs.map(s => sp(argIndent) + s).join('\n') + ')'
+  return (
+    '(' +
+    headStr +
+    '\n' +
+    argStrs.map((s) => sp(argIndent) + s).join('\n') +
+    ')'
+  )
 }
 
-function ppVec(items: CljValue[], col: number, maxWidth: number, pairMode: boolean): string {
+function ppVec(
+  items: CljValue[],
+  col: number,
+  maxWidth: number,
+  pairMode: boolean
+): string {
   if (items.length === 0) return '[]'
 
   const innerCol = col + 1
@@ -403,7 +502,11 @@ function ppVec(items: CljValue[], col: number, maxWidth: number, pairMode: boole
   return '[' + strs.join('\n') + ']'
 }
 
-function ppMap(entries: [CljValue, CljValue][], col: number, maxWidth: number): string {
+function ppMap(
+  entries: [CljValue, CljValue][],
+  col: number,
+  maxWidth: number
+): string {
   if (entries.length === 0) return '{}'
   const innerCol = col + 1
   const pairs = entries.map(([k, v], i) => {
@@ -437,7 +540,13 @@ function ppPairs(items: CljValue[], indent: number, maxWidth: number): string {
     if (indent + pairFlat.length <= maxWidth) {
       lines.push(sp(indent) + pairFlat)
     } else {
-      lines.push(sp(indent) + testStr + '\n' + sp(indent + 2) + pp(items[i + 1], indent + 2, maxWidth))
+      lines.push(
+        sp(indent) +
+          testStr +
+          '\n' +
+          sp(indent + 2) +
+          pp(items[i + 1], indent + 2, maxWidth)
+      )
     }
   }
   return lines.join('\n')

package/src/core/reader.ts

@@ -3,9 +3,15 @@ import { v } from './factories'
 import { is } from './assertions'
 import { makeTokenScanner, type TokenScanner } from './scanners'
 import { getTokenValue } from './tokenizer'
-import { valueKeywords, tokenKeywords, type Token } from './types'
-import type { CljValue, TokenKinds } from './types'
+import { type Token } from './types'
+import type { CljValue } from './types'
 import { getPos, setPos } from './positions'
+import {
+  tokenKeywords,
+  type TokenKinds,
+  tokenSymbols,
+  valueKeywords,
+} from './keywords.ts'
 
 function readAtom(ctx: ReaderCtx): CljValue {
   const scanner = ctx.scanner
@@ -18,13 +24,13 @@ function readAtom(ctx: ReaderCtx): CljValue {
       return readSymbol(scanner)
     case tokenKeywords.String: {
       scanner.advance()
-      const val: CljValue = { kind: 'string', value: token.value }
+      const val: CljValue = v.string(token.value)
       setPos(val, { start: token.start.offset, end: token.end.offset })
       return val
     }
     case tokenKeywords.Number: {
       scanner.advance()
-      const val: CljValue = { kind: 'number', value: token.value }
+      const val: CljValue = v.number(token.value)
       setPos(val, { start: token.start.offset, end: token.end.offset })
       return val
     }
@@ -46,12 +52,12 @@ function readAtom(ctx: ReaderCtx): CljValue {
               { start: token.start.offset, end: token.end.offset }
             )
           }
-          val = { kind: 'keyword', name: `:${fullNs}/${localName}` }
+          val = v.keyword(`:${fullNs}/${localName}`)
         } else {
-          val = { kind: 'keyword', name: `:${ctx.namespace}/${rest}` }
+          val = v.keyword(`:${ctx.namespace}/${rest}`)
         }
       } else {
-        val = { kind: 'keyword', name: kwName }
+        val = v.keyword(kwName)
       }
       setPos(val, { start: token.start.offset, end: token.end.offset })
       return val
@@ -78,7 +84,7 @@ const readQuote = (ctx: ReaderCtx) => {
   if (!value) {
     throw new ReaderError(`Unexpected token: ${getTokenValue(token)}`, token)
   }
-  return { kind: valueKeywords.list, value: [v.symbol('quote'), value] }
+  return v.list([v.symbol('quote'), value])
 }
 
 const readQuasiquote = (ctx: ReaderCtx) => {
@@ -95,7 +101,7 @@ const readQuasiquote = (ctx: ReaderCtx) => {
   if (!value) {
     throw new ReaderError(`Unexpected token: ${getTokenValue(token)}`, token)
   }
-  return { kind: valueKeywords.list, value: [v.symbol('quasiquote'), value] }
+  return v.list([v.symbol('quasiquote'), value])
 }
 
 const readUnquote = (ctx: ReaderCtx) => {
@@ -112,7 +118,7 @@ const readUnquote = (ctx: ReaderCtx) => {
   if (!value) {
     throw new ReaderError(`Unexpected token: ${getTokenValue(token)}`, token)
   }
-  return { kind: valueKeywords.list, value: [v.symbol('unquote'), value] }
+  return v.list([v.symbol('unquote'), value])
 }
 
 const readMeta = (ctx: ReaderCtx): CljValue => {
@@ -131,11 +137,11 @@ const readMeta = (ctx: ReaderCtx): CljValue => {
 
   // Convert metaForm to a CljMap
   let metaEntries: [CljValue, CljValue][]
-  if (metaForm.kind === 'keyword') {
+  if (is.keyword(metaForm)) {
     metaEntries = [[metaForm, v.boolean(true)]]
-  } else if (metaForm.kind === 'map') {
+  } else if (is.map(metaForm)) {
     metaEntries = metaForm.entries
-  } else if (metaForm.kind === 'symbol') {
+  } else if (is.symbol(metaForm)) {
     metaEntries = [[v.keyword(':tag'), metaForm]]
   } else {
     throw new ReaderError('Metadata must be a keyword, map, or symbol', token)
@@ -143,10 +149,10 @@ const readMeta = (ctx: ReaderCtx): CljValue => {
 
   // Attach metadata to IMeta targets: symbols, lists, vectors, maps.
   if (
-    target.kind === 'symbol' ||
-    target.kind === 'list' ||
-    target.kind === 'vector' ||
-    target.kind === 'map'
+    is.symbol(target) ||
+    is.list(target) ||
+    is.vector(target) ||
+    is.map(target)
   ) {
     const existingEntries = target.meta ? target.meta.entries : []
     const result = {
@@ -206,10 +212,7 @@ const readUnquoteSplicing = (ctx: ReaderCtx) => {
   if (!value) {
     throw new ReaderError(`Unexpected token: ${getTokenValue(token)}`, token)
   }
-  return {
-    kind: valueKeywords.list,
-    value: [v.symbol('unquote-splicing'), value],
-  }
+  return v.list([v.symbol(tokenSymbols.UnquoteSplicing), value])
 }
 
 const isClosingToken = (token: Token) => {
@@ -537,7 +540,7 @@ const readAnonFn = (ctx: ReaderCtx) => {
   }
 
   // The entire body content is a single implicit list — #(* 2 %) ≡ (fn [p1] (* 2 p1))
-  const bodyList: CljValue = { kind: 'list', value: bodyForms }
+  const bodyList: CljValue = v.list(bodyForms)
 
   const { maxIndex, hasRest } = collectAnonFnParams([bodyList])
 

package/src/core/registry.ts

@@ -1,4 +1,4 @@
-import { isKeyword, isSymbol, isVector } from './assertions'
+import { is } from './assertions'
 import { makeEnv, makeNamespace } from './env'
 import { EvaluationError } from './errors'
 import type { CljValue, Env } from './types'
@@ -89,7 +89,7 @@ export function processRequireSpec(
   registry: NamespaceRegistry,
   resolveNs?: (nsName: string) => boolean
 ): void {
-  if (!isVector(spec)) {
+  if (!is.vector(spec)) {
     throw new EvaluationError(
       'require spec must be a vector, e.g. [my.ns :as alias]',
       { spec }
@@ -97,7 +97,7 @@ export function processRequireSpec(
   }
 
   const elements = spec.value
-  if (elements.length === 0 || !isSymbol(elements[0])) {
+  if (elements.length === 0 || !is.symbol(elements[0])) {
     throw new EvaluationError(
       'First element of require spec must be a namespace symbol',
       { spec }
@@ -107,13 +107,13 @@ export function processRequireSpec(
   const nsName = elements[0].name
 
   const hasAsAlias = elements.some(
-    (el) => isKeyword(el) && el.name === ':as-alias'
+    (el) => is.keyword(el) && el.name === ':as-alias'
   )
   if (hasAsAlias) {
     let i = 1
     while (i < elements.length) {
       const kw = elements[i]
-      if (!isKeyword(kw)) {
+      if (!is.keyword(kw)) {
         throw new EvaluationError(
           `Expected keyword in require spec, got ${kw.kind}`,
           { spec, position: i }
@@ -122,7 +122,7 @@ export function processRequireSpec(
       if (kw.name === ':as-alias') {
         i++
         const alias = elements[i]
-        if (!alias || !isSymbol(alias)) {
+        if (!alias || !is.symbol(alias)) {
           throw new EvaluationError(':as-alias expects a symbol alias', {
             spec,
             position: i,
@@ -155,7 +155,7 @@ export function processRequireSpec(
   let i = 1
   while (i < elements.length) {
     const kw = elements[i]
-    if (!isKeyword(kw)) {
+    if (!is.keyword(kw)) {
       throw new EvaluationError(
         `Expected keyword in require spec, got ${kw.kind}`,
         { spec, position: i }
@@ -165,7 +165,7 @@ export function processRequireSpec(
     if (kw.name === ':as') {
       i++
       const alias = elements[i]
-      if (!alias || !isSymbol(alias)) {
+      if (!alias || !is.symbol(alias)) {
         throw new EvaluationError(':as expects a symbol alias', {
           spec,
           position: i,
@@ -176,14 +176,14 @@ export function processRequireSpec(
     } else if (kw.name === ':refer') {
       i++
       const symsVec = elements[i]
-      if (!symsVec || !isVector(symsVec)) {
+      if (!symsVec || !is.vector(symsVec)) {
         throw new EvaluationError(':refer expects a vector of symbols', {
           spec,
           position: i,
         })
       }
       for (const sym of symsVec.value) {
-        if (!isSymbol(sym)) {
+        if (!is.symbol(sym)) {
           throw new EvaluationError(':refer vector must contain only symbols', {
             spec,
             sym,

package/src/core/runtime.ts

@@ -1,30 +1,30 @@
-import { isKeyword, isString, isSymbol, isVector } from './assertions'
+import { builtInNamespaceSources } from '../clojure/generated/builtin-namespace-registry'
+import { is } from './assertions'
+import { wireIdeStubs, wireNsCore } from './bootstrap'
+import { internVar, makeEnv, makeNamespace } from './env'
+import { EvaluationError } from './errors'
+import { v } from './factories'
 import {
   resolveModuleOrder,
-  type RuntimeModule,
   type ModuleContext,
+  type RuntimeModule,
 } from './module'
-import { internVar, makeEnv, makeNamespace } from './env'
-import { EvaluationError } from './errors'
-import { v } from './factories'
+import { makeCoreModule } from './modules/core'
+import { makeJsModule } from './modules/js'
+import {
+  extractAliasMapFromTokens,
+  extractNsNameFromTokens,
+  extractRequireClauses,
+} from './ns-forms'
 import { readForms } from './reader'
-import { tokenize } from './tokenizer'
-import type { CljNamespace, CljValue, Env, EvaluationContext } from './types'
-import { builtInNamespaceSources } from '../clojure/generated/builtin-namespace-registry'
-import { makeCoreModule } from './core-module'
-import { makeJsModule } from './stdlib/js-namespace'
+import type { NamespaceRegistry } from './registry'
 import {
   cloneRegistry,
   ensureNamespaceInRegistry,
   processRequireSpec,
 } from './registry'
-import type { NamespaceRegistry } from './registry'
-import {
-  extractAliasMapFromTokens,
-  extractNsNameFromTokens,
-  extractRequireClauses,
-} from './ns-forms'
-import { wireIdeStubs, wireNsCore } from './bootstrap'
+import { tokenize } from './tokenizer'
+import type { CljNamespace, CljValue, Env, EvaluationContext } from './types'
 
 // ---------------------------------------------------------------------------
 // Core types
@@ -184,9 +184,9 @@ function buildRuntime(
       for (const specs of requireClauses) {
         for (const spec of specs) {
           if (
-            isVector(spec) &&
+            is.vector(spec) &&
             spec.value.length > 0 &&
-            isString(spec.value[0])
+            is.string(spec.value[0])
           ) {
             const specifier = spec.value[0].value
             throw new EvaluationError(
@@ -210,9 +210,9 @@ function buildRuntime(
       for (const specs of requireClauses) {
         for (const spec of specs) {
           if (
-            isVector(spec) &&
+            is.vector(spec) &&
             spec.value.length > 0 &&
-            isString(spec.value[0])
+            is.string(spec.value[0])
           ) {
             // String module require — calls importModule and interns result as a var
             const specifier = spec.value[0].value
@@ -226,12 +226,12 @@ function buildRuntime(
             let aliasName: string | null = null
             for (let i = 1; i < elements.length; i++) {
               if (
-                isKeyword(elements[i]) &&
+                is.keyword(elements[i]) &&
                 (elements[i] as { name: string }).name === ':as'
               ) {
                 i++
                 const aliasSym = elements[i]
-                if (!aliasSym || !isSymbol(aliasSym)) {
+                if (!aliasSym || !is.symbol(aliasSym)) {
                   throw new EvaluationError(':as expects a symbol alias', {
                     spec,
                   })