@o3co/ts.hocon 0.1.0 → 0.1.2

package/src/parse.ts

@@ -1,79 +0,0 @@
-import { tokenize } from './internal/lexer/lexer.js'
-import { parseTokens } from './internal/parser/parser.js'
-import { resolve } from './internal/resolver/resolver.js'
-import { Config } from './config.js'
-import type { ResolveOptions } from './internal/resolver/resolver.js'
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-export type ParseOptions = {
-  baseDir?: string
-  env?: Record<string, string>
-  readFile?: (filePath: string) => Promise<string>
-  readFileSync?: (filePath: string) => string
-}
-
-function getEnv(opts: ParseOptions): Record<string, string> {
-  if (opts.env !== undefined) return opts.env
-  if (typeof process !== 'undefined' && process.env) return process.env as Record<string, string>
-  return {}
-}
-
-function defaultReadFileSync(filePath: string): string {
-  return fs.readFileSync(filePath, 'utf-8')
-}
-
-async function defaultReadFile(filePath: string): Promise<string> {
-  return fs.promises.readFile(filePath, 'utf-8')
-}
-
-export function parse(input: string, opts: ParseOptions = {}): Config {
-  const tokens = tokenize(input)
-  const ast = parseTokens(tokens)
-  const resolveOpts: ResolveOptions = {
-    env: getEnv(opts),
-    baseDir: opts.baseDir,
-    readFileSync: opts.readFileSync ?? defaultReadFileSync,
-  }
-  const value = resolve(ast, resolveOpts)
-  if (value.kind !== 'object') throw new Error('resolved value is not an object')
-  return new Config(value)
-}
-
-/**
- * Async wrapper around `parse()`. Returns a resolved Promise — the parsing
- * itself is synchronous. Use `parseFileAsync()` for async file I/O.
- * Note: `include` directives in string input are resolved synchronously
- * via `readFileSync`; `readFile` is not used by this function.
- */
-export async function parseAsync(input: string, opts: ParseOptions = {}): Promise<Config> {
-  return Promise.resolve(parse(input, opts))
-}
-
-export function parseFile(filePath: string, opts: ParseOptions = {}): Config {
-  if (typeof process === 'undefined' && !opts.readFileSync) {
-    throw new Error('parseFile is not supported in browser environments. Provide opts.readFileSync or use parse() instead.')
-  }
-  const resolvedPath = path.resolve(filePath)
-  const readFileSync = opts.readFileSync ?? defaultReadFileSync
-  const input = readFileSync(resolvedPath)
-  return parse(input, {
-    ...opts,
-    baseDir: opts.baseDir ?? path.dirname(resolvedPath),
-    readFileSync,
-  })
-}
-
-export async function parseFileAsync(filePath: string, opts: ParseOptions = {}): Promise<Config> {
-  if (typeof process === 'undefined' && !opts.readFile) {
-    throw new Error('parseFileAsync is not supported in browser environments. Provide opts.readFile or use parseAsync() instead.')
-  }
-  const resolvedPath = path.resolve(filePath)
-  const readFile = opts.readFile ?? defaultReadFile
-  const input = await readFile(resolvedPath)
-  return parse(input, {
-    ...opts,
-    baseDir: opts.baseDir ?? path.dirname(resolvedPath),
-    readFileSync: opts.readFileSync ?? defaultReadFileSync,
-  })
-}

package/src/value.ts

@@ -1,5 +0,0 @@
-// JavaScript の Map は挿入順を保証するため keys フィールド不要
-export type HoconValue =
-  | { kind: 'object'; fields: Map<string, HoconValue> }
-  | { kind: 'array'; items: HoconValue[] }
-  | { kind: 'scalar'; value: string | number | boolean | null }

package/src/zod.ts

@@ -1,12 +0,0 @@
-import type { ZodType } from 'zod'
-import type { Config } from './config.js'
-
-export function validate<T>(config: Config, schema: ZodType<T>): T {
-  const plain = config.toObject()
-  return schema.parse(plain)
-}
-
-export function getValidated<T>(config: Config, path: string, schema: ZodType<T>): T {
-  const val = config.get(path)
-  return schema.parse(val)
-}

package/tests/config.test.ts

@@ -1,100 +0,0 @@
-// tests/config.test.ts
-import { describe, it, expect } from 'vitest'
-import { Config } from '../src/config.js'
-import type { HoconValue } from '../src/value.js'
-import { ConfigError } from '../src/errors.js'
-
-function makeConfig(obj: Record<string, HoconValue>): Config {
-  return new Config({ kind: 'object', fields: new Map(Object.entries(obj)) })
-}
-
-describe('Config', () => {
-  it('get() returns value at path', () => {
-    const c = makeConfig({ host: { kind: 'scalar', value: 'localhost' } })
-    expect(c.get('host')).toBe('localhost')
-  })
-
-  it('get() returns nested value at dot-path', () => {
-    const inner = new Map([['host', { kind: 'scalar', value: 'localhost' } satisfies HoconValue]])
-    const c = new Config({ kind: 'object', fields: new Map([['server', { kind: 'object', fields: inner }]]) })
-    expect(c.get('server.host')).toBe('localhost')
-  })
-
-  it('get() returns undefined for missing path', () => {
-    const c = makeConfig({})
-    expect(c.get('missing')).toBeUndefined()
-  })
-
-  it('getString() returns string value', () => {
-    const c = makeConfig({ host: { kind: 'scalar', value: 'localhost' } })
-    expect(c.getString('host')).toBe('localhost')
-  })
-
-  it('getString() throws ConfigError for non-string', () => {
-    const c = makeConfig({ port: { kind: 'scalar', value: 8080 } })
-    expect(() => c.getString('port')).toThrow(ConfigError)
-  })
-
-  it('getNumber() returns number value', () => {
-    const c = makeConfig({ port: { kind: 'scalar', value: 8080 } })
-    expect(c.getNumber('port')).toBe(8080)
-  })
-
-  it('getNumber() throws ConfigError for non-number', () => {
-    const c = makeConfig({ host: { kind: 'scalar', value: 'localhost' } })
-    expect(() => c.getNumber('host')).toThrow(ConfigError)
-  })
-
-  it('getBoolean() returns boolean value', () => {
-    const c = makeConfig({ debug: { kind: 'scalar', value: true } })
-    expect(c.getBoolean('debug')).toBe(true)
-  })
-
-  it('getConfig() returns sub-config', () => {
-    const inner = new Map([['host', { kind: 'scalar', value: 'localhost' } satisfies HoconValue]])
-    const c = new Config({ kind: 'object', fields: new Map([['server', { kind: 'object', fields: inner }]]) })
-    const sub = c.getConfig('server')
-    expect(sub).toBeInstanceOf(Config)
-    expect(sub.getString('host')).toBe('localhost')
-  })
-
-  it('getList() returns array as unknown[]', () => {
-    const items: HoconValue[] = [{ kind: 'scalar', value: 1 }, { kind: 'scalar', value: 2 }]
-    const c = makeConfig({ list: { kind: 'array', items } })
-    expect(c.getList('list')).toEqual([1, 2])
-  })
-
-  it('has() returns true for existing key', () => {
-    const c = makeConfig({ host: { kind: 'scalar', value: 'localhost' } })
-    expect(c.has('host')).toBe(true)
-  })
-
-  it('has() returns true for null value', () => {
-    const c = makeConfig({ x: { kind: 'scalar', value: null } })
-    expect(c.has('x')).toBe(true)
-  })
-
-  it('has() returns false for missing key', () => {
-    const c = makeConfig({})
-    expect(c.has('missing')).toBe(false)
-  })
-
-  it('keys() returns top-level keys in order', () => {
-    const c = new Config({ kind: 'object', fields: new Map([['b', { kind: 'scalar', value: 2 }], ['a', { kind: 'scalar', value: 1 }]]) })
-    expect(c.keys()).toEqual(['b', 'a'])
-  })
-
-  it('withFallback() receiver wins', () => {
-    const c1 = makeConfig({ host: { kind: 'scalar', value: 'prod' } })
-    const c2 = makeConfig({ host: { kind: 'scalar', value: 'dev' }, port: { kind: 'scalar', value: 8080 } })
-    const merged = c1.withFallback(c2)
-    expect(merged.getString('host')).toBe('prod')
-    expect(merged.getNumber('port')).toBe(8080)
-  })
-
-  it('toObject() converts to plain JS object recursively', () => {
-    const inner = new Map([['host', { kind: 'scalar', value: 'localhost' } satisfies HoconValue]])
-    const c = new Config({ kind: 'object', fields: new Map([['server', { kind: 'object', fields: inner }]]) })
-    expect(c.toObject()).toEqual({ server: { host: 'localhost' } })
-  })
-})

package/tests/errors.test.ts

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { ParseError, ResolveError, ConfigError } from '../src/errors.js'
-
-describe('ParseError', () => {
-  it('is an Error with line/col', () => {
-    const e = new ParseError('unexpected token', 3, 10)
-    expect(e).toBeInstanceOf(Error)
-    expect(e.message).toBe('unexpected token')
-    expect(e.line).toBe(3)
-    expect(e.col).toBe(10)
-    expect(e.file).toBeUndefined()
-  })
-
-  it('accepts optional file path', () => {
-    const e = new ParseError('bad syntax', 1, 1, 'app.conf')
-    expect(e.file).toBe('app.conf')
-  })
-})
-
-describe('ResolveError', () => {
-  it('carries path and position', () => {
-    const e = new ResolveError('unresolved substitution', 'server.host', 5, 3)
-    expect(e).toBeInstanceOf(Error)
-    expect(e.path).toBe('server.host')
-    expect(e.line).toBe(5)
-    expect(e.col).toBe(3)
-  })
-
-  it('line/col can be 0 (no position info)', () => {
-    const e = new ResolveError('include failed', 'path', 0, 0, 'app.conf')
-    expect(e.line).toBe(0)
-    expect(e.col).toBe(0)
-    expect(e.file).toBe('app.conf')
-  })
-})
-
-describe('ConfigError', () => {
-  it('carries path', () => {
-    const e = new ConfigError('key not found', 'server.port')
-    expect(e).toBeInstanceOf(Error)
-    expect(e.path).toBe('server.port')
-  })
-})

package/tests/lexer.test.ts

@@ -1,141 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { tokenize } from '../src/internal/lexer/lexer.js'
-import { ParseError } from '../src/errors.js'
-
-describe('tokenize', () => {
-  it('tokenizes empty string', () => {
-    const tokens = tokenize('')
-    expect(tokens).toHaveLength(1)
-    expect(tokens[0].kind).toBe('eof')
-  })
-
-  it('tokenizes braces and brackets', () => {
-    const tokens = tokenize('{}[]')
-    expect(tokens.map(t => t.kind)).toEqual(['lbrace', 'rbrace', 'lbracket', 'rbracket', 'eof'])
-  })
-
-  it('tokenizes = and +=', () => {
-    const tokens = tokenize('=+=')
-    expect(tokens[0].kind).toBe('equals')
-    expect(tokens[1].kind).toBe('plus_equals')
-  })
-
-  it('tokenizes : and ,', () => {
-    const tokens = tokenize(':,')
-    expect(tokens.map(t => t.kind)).toEqual(['colon', 'comma', 'eof'])
-  })
-
-  it('skips // comments, keeps newline', () => {
-    const tokens = tokenize('// comment\nfoo')
-    expect(tokens[0].kind).toBe('newline')
-    expect(tokens[1].kind).toBe('unquoted')
-    expect(tokens[1].value).toBe('foo')
-  })
-
-  it('skips # comments', () => {
-    const tokens = tokenize('# comment\nfoo')
-    expect(tokens[0].kind).toBe('newline')
-    expect(tokens[1].value).toBe('foo')
-  })
-
-  it('tokenizes quoted strings', () => {
-    const [t] = tokenize('"hello world"')
-    expect(t.kind).toBe('string')
-    expect(t.value).toBe('hello world')
-    expect(t.isQuoted).toBe(true)
-  })
-
-  it('handles escape sequences', () => {
-    const [t] = tokenize('"a\\nb\\tc"')
-    expect(t.value).toBe('a\nb\tc')
-  })
-
-  it('handles \\u unicode escapes', () => {
-    const [t] = tokenize('"\\u0041"')
-    expect(t.value).toBe('A')
-  })
-
-  it('tokenizes triple-quoted strings', () => {
-    const [t] = tokenize('"""hello\nworld"""')
-    expect(t.kind).toBe('triple_string')
-    expect(t.value).toBe('hello\nworld')
-    expect(t.isQuoted).toBe(true)
-  })
-
-  it('strips leading newline from triple-quoted strings', () => {
-    const [t] = tokenize('"""\nhello"""')
-    expect(t.value).toBe('hello')
-  })
-
-  it('tokenizes unquoted strings', () => {
-    const [t] = tokenize('localhost')
-    expect(t.kind).toBe('unquoted')
-    expect(t.value).toBe('localhost')
-    expect(t.isQuoted).toBe(false)
-  })
-
-  it('tokenizes numbers as unquoted', () => {
-    const [t] = tokenize('8080')
-    expect(t.kind).toBe('unquoted')
-    expect(t.value).toBe('8080')
-  })
-
-  it('tokenizes substitutions', () => {
-    const [t] = tokenize('${server.host}')
-    expect(t.kind).toBe('subst')
-    expect(t.value).toBe('server.host')
-  })
-
-  it('tokenizes optional substitutions', () => {
-    const [t] = tokenize('${?foo}')
-    expect(t.kind).toBe('opt_subst')
-    expect(t.value).toBe('foo')
-  })
-
-  it('tokenizes newlines', () => {
-    const tokens = tokenize('a\nb')
-    expect(tokens[1].kind).toBe('newline')
-  })
-
-  it('deduplicates consecutive newlines', () => {
-    const tokens = tokenize('a\n\n\nb')
-    const newlines = tokens.filter(t => t.kind === 'newline')
-    expect(newlines).toHaveLength(1)
-  })
-
-  it('tracks line and col', () => {
-    const tokens = tokenize('a\nb')
-    expect(tokens[0].line).toBe(1)
-    expect(tokens[0].col).toBe(1)
-    expect(tokens[2].line).toBe(2)
-    expect(tokens[2].col).toBe(1)
-  })
-
-  it('sets precedingSpace on token after whitespace', () => {
-    const tokens = tokenize('a b')
-    expect(tokens[1].precedingSpace).toBe(true)
-    expect(tokens[0].precedingSpace).toBe(false)
-  })
-
-  it('strips UTF-8 BOM', () => {
-    const tokens = tokenize('\uFEFFfoo')
-    expect(tokens[0].value).toBe('foo')
-  })
-
-  it('stops unquoted scan at $ for concat', () => {
-    const tokens = tokenize('foo${bar}')
-    expect(tokens[0].kind).toBe('unquoted')
-    expect(tokens[0].value).toBe('foo')
-    expect(tokens[1].kind).toBe('subst')
-    expect(tokens[1].value).toBe('bar')
-    expect(tokens[1].precedingSpace).toBe(false)
-  })
-
-  it('throws ParseError on unterminated string', () => {
-    expect(() => tokenize('"unterminated')).toThrow(ParseError)
-  })
-
-  it('throws ParseError on unterminated substitution', () => {
-    expect(() => tokenize('${foo')).toThrow(ParseError)
-  })
-})

package/tests/lightbend/lightbend.test.ts

@@ -1,39 +0,0 @@
-// tests/lightbend/lightbend.test.ts
-//
-// Lightbend HOCON spec compliance tests, mirroring go.hocon's lightbend_test.go.
-// Tests equiv01-05 directories (each .conf compared against original.json).
-import { describe, it, expect } from 'vitest'
-import { existsSync, readdirSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import { parse } from '../../src/parse.js'
-
-const dataDir = new URL('./testdata', import.meta.url).pathname
-
-// Known skip reasons for specific test files
-const equivSkip = new Set([
-  'equiv03/includes.conf', // requires .properties file support
-])
-
-describe('Lightbend HOCON equiv tests', () => {
-  for (let i = 1; i <= 5; i++) {
-    const dir = join(dataDir, `equiv${String(i).padStart(2, '0')}`)
-    const jsonPath = join(dir, 'original.json')
-    if (!existsSync(jsonPath)) continue
-
-    const expected = JSON.parse(readFileSync(jsonPath, 'utf-8'))
-    const entries = readdirSync(dir)
-
-    for (const entry of entries) {
-      if (!entry.endsWith('.conf')) continue
-      const rel = `equiv${String(i).padStart(2, '0')}/${entry}`
-      if (equivSkip.has(rel)) continue
-
-      it(rel, () => {
-        const confPath = join(dir, entry)
-        const confContent = readFileSync(confPath, 'utf-8')
-        const config = parse(confContent, { baseDir: dir })
-        expect(config.toObject()).toEqual(expected)
-      })
-    }
-  }
-})

package/tests/lightbend/testdata/a_1.conf

@@ -1 +0,0 @@
-a=1

package/tests/lightbend/testdata/b_2.conf

@@ -1 +0,0 @@
-b=2

package/tests/lightbend/testdata/beanconfig/beanconfig01.conf

@@ -1,131 +0,0 @@
-{
-  "booleans" : {
-      "trueVal" : true,
-      "trueValAgain" : ${booleans.trueVal},
-      "falseVal" : false,
-      "falseValAgain" : ${booleans.falseVal},
-      "on" : "on",
-      "off" : "off"
-  }
-
-    "numbers" : {
-       "byteVal" : "1",
-       "byteObj" : ${numbers.byteVal},
-       "shortVal" : "2",
-       "shortObj" : ${numbers.shortVal},
-       "intVal" : "3",
-       "intObj" : ${numbers.intVal},
-       "longVal" : "4",
-       "longObj" : ${numbers.longVal},
-       "doubleVal" : "1.0",
-       "doubleObj" : ${numbers.doubleVal}
-    }
-//
-    "strings" : {
-        "abcd" : "abcd",
-        "abcd-again" : ${strings.a}${strings.b}${strings.c}${strings.d},
-        "a" : "a",
-        "b" : "b",
-        "c" : "c",
-        "d" : "d",
-        "concatenated" : null bar 42 baz true 3.14 hi,
-        "double" : "3.14",
-        "number" : "57",
-        "null" : "null",
-        "true" : "true",
-        "yes" : "yes",
-        "false" : "false",
-        "no" : "no"
-    },
-
-    "arrays" : {
-        "empty" : [],
-        "ofInt" : [1, 2, 3],
-        "ofString" : [ ${strings.a}, ${strings.b}, ${strings.c} ],
-        "of-double" : [3.14, 4.14, 5.14],
-        "of-long" : { "1" : 32, "2" : 42, "3" : 52 }, // object-to-list conversion
-        "ofNull" : [null, null, null],
-        "ofBoolean" : [true, false],
-        "ofArray" : [${arrays.ofString}, ${arrays.ofString}, ${arrays.ofString}],
-        "ofObject" : [${numbers}, ${booleans}, ${strings}],
-        "ofConfig" : [${numbers}, ${booleans}, ${strings}],
-        "ofConfigObject" : [${numbers}, ${booleans}, ${strings}],
-        "ofConfigValue" : [1, 2, "a"],
-        "ofDuration" : [1, 2h, 3 days],
-        "ofMemorySize" : [1024, 1M, 1G],
-        "ofStringBean" : [
-                {
-                        abcd : "testAbcdOne"
-                        yes : "testYesOne"
-                },
-                {
-                        abcd : "testAbcdTwo"
-                        yes : "testYesTwo"
-                }
-        ]
-    },
-    "bytes" : {
-        "kilobyte" : "1kB",
-        "kibibyte" : "1K",
-        "thousandBytes" : "1000B"
-    },
-    "durations" : {
-        "second" : 1s,
-        "secondAsNumber" : 1000,
-        "halfSecond" : 0.5s
-    },
-    "validation" : {
-      "shouldBeInt" : true,
-      "should-be-boolean" : 42,
-      "should-be-list" : "hello"
-    },
-    "preferCamelNames" : {
-      "foo-bar" : "no",
-      "fooBar" : "yes",
-      "baz-bar" : "no",
-      "bazBar" : "yes"
-    },
-    "values" : {
-      "obj" : 42,
-      "config" : ${strings},
-      "configObj" : ${numbers},
-      "configValue" : "hello world",
-      "list" : [1,2,3],
-      "unwrappedMap" : ${validation}
-    },
-    "enums" : {
-      "problem" : "P1",
-      "solutions" : ["S1", "S3"]
-    },
-    "objects" : {
-      "valueObject": {
-        "mandatoryValue": "notNull"
-      }
-    },
-    "sets" : {
-      "empty" : [],
-      "ofInt" : [1, 2, 3, 2, 3],
-      "ofString" : [ ${strings.a}, ${strings.b}, ${strings.c} ],
-      "of-double" : [3.14, 4.14, 4.14, 5.14],
-      "of-long" : { "1" : 32, "2" : 42, "3" : 52 }, // object-to-list conversion
-      "ofNull" : [null, null, null],
-      "ofBoolean" : [true, false, false],
-      "ofArray" : [${arrays.ofString}, ${arrays.ofString}, ${arrays.ofString}],
-      "ofObject" : [${numbers}, ${booleans}, ${strings}],
-      "ofConfig" : [${numbers}, ${booleans}, ${strings}],
-      "ofConfigObject" : [${numbers}, ${booleans}, ${strings}],
-      "ofConfigValue" : [1, 2, "a"],
-      "ofDuration" : [1, 2h, 3 days],
-      "ofMemorySize" : [1024, 1M, 1G],
-      "ofStringBean" : [
-        {
-          abcd : "testAbcdOne"
-          yes : "testYesOne"
-        },
-        {
-          abcd : "testAbcdTwo"
-          yes : "testYesTwo"
-        }
-      ]
-    }
-}

package/tests/lightbend/testdata/bom.conf

@@ -1,2 +0,0 @@
-#
-foo = bar

package/tests/lightbend/testdata/cycle.conf

@@ -1 +0,0 @@
-include "cycle.conf"

package/tests/lightbend/testdata/env-variables.conf

@@ -1,16 +0,0 @@
-secret = a
-secret = ${?SECRET_A}
-secrets = ["b", "c"]
-secrets = [${?SECRET_B}, ${?SECRET_C}]
-
-myList = ${MY_LIST[]}
-myOptionalList = ${?MY_LIST[]}
-myOptionalUndefinedList = ${?UNDEFINED_LIST[]}
-numList = ${NUM_LIST[]}
-
-# list concatenation with env var list expansion
-prependedList = ["x", "y"] ${?MY_LIST[]}
-appendedList = ${?MY_LIST[]} ["x", "y"]
-selfAppendedList = ["x"]
-selfAppendedList = ${?selfAppendedList} ${?MY_LIST[]}
-appendedUndefined = ["x", "y"] ${?UNDEFINED_LIST[]}

package/tests/lightbend/testdata/equiv01/comments.conf

@@ -1,45 +0,0 @@
-{  // These are some integers
-    "ints" : { # we can comment them with # too
-        "fortyTwo" : 42, ## double-# !
-        "fortyTwoAgain" : 42 # { }
-    },
-######## COMMENT COMMENT COMMENT
-/// I COMMENT YOU
-    "floats" : {
-        "fortyTwoPointOne" : 42.1,
-        "fortyTwoPointOneAgain" : 42.1
-        // I CAN HAS COMMENT
-    },
-
-    "strings" : {
-        "abcd" : // I got yr comment right here
-  "abcd",
-        "abcdAgain" : "abcd",
-        "a" : "a",
-        "b" : "b",
-        "c" : "c",
-        "d" : "d",
-        "concatenated" # more to say?
-: "null bar 42 baz true 3.14 hi"
-    },
-
-    "arrays" : {
-        "empty" : [],
-        "1" : [ 1 ],
-        "12" : [1, 2],
-        "123" : [1, 2, 3],
-        "ofString" : [ "a", "b", "c" ]
-    },
-
-    "booleans" : {
-        "true" : true,
-        "trueAgain" : true,
-        "false" : false,
-        "falseAgain" : false
-    },
-
-    "nulls" : {
-        "null" : null,
-        "nullAgain" : null
-    }
-}

package/tests/lightbend/testdata/equiv01/equals.conf

@@ -1,41 +0,0 @@
-{
-    "ints" = {
-        "fortyTwo" = 42,
-        "fortyTwoAgain" = 42
-    },
-
-    "floats" = {
-        "fortyTwoPointOne" = 42.1,
-        "fortyTwoPointOneAgain" = 42.1
-    },
-
-    "strings" = {
-        "abcd" = "abcd",
-        "abcdAgain" = "abcd",
-        "a" = "a",
-        "b" = "b",
-        "c" = "c",
-        "d" = "d",
-        "concatenated" = "null bar 42 baz true 3.14 hi"
-    },
-
-    "arrays" = {
-        "empty" = [],
-        "1" = [ 1 ],
-        "12" = [1, 2],
-        "123" = [1, 2, 3],
-        "ofString" = [ "a", "b", "c" ]
-    },
-
-    "booleans" = {
-        "true" = true,
-        "trueAgain" = true,
-        "false" = false,
-        "falseAgain" = false
-    },
-
-    "nulls" = {
-        "null" = null,
-        "nullAgain" = null
-    }
-}