zeed 1.4.0 → 1.8.0

package/src/common/bin/lib0/decoding.spec.ts

@@ -1,4 +1,5 @@
-import { createDecoder, peekUint8, peekUint16, peekUint32, peekVarInt, peekVarString, peekVarUint, readAny, readBigInt64, readBigUint64, readFloat32, readFloat64, readUint8, readUint16, readUint32, readUint32BigEndian, readVarInt, readVarString, readVarUint, readVarUint8Array } from './decoding'
+import { afterEach, vi } from 'vitest'
+import { clone, createDecoder, hasContent, peekUint8, peekUint16, peekUint32, peekVarInt, peekVarString, peekVarUint, readAny, readBigInt64, readBigUint64, readFloat32, readFloat64, readTailAsUint8Array, readUint8, readUint16, readUint32, readUint32BigEndian, readVarInt, readVarString, readVarUint, readVarUint8Array, skip8 } from './decoding'
 import { createBinEncoder, writeAny, writeBigInt64, writeBigUint64, writeFloat32, writeFloat64, writeUint8, writeUint16, writeUint32, writeVarInt, writeVarString, writeVarUint, writeVarUint8Array } from './encoding'
 
 describe('lib0/decoding', () => {
@@ -79,6 +80,88 @@ describe('lib0/decoding', () => {
     expect(readAny(d)).toEqual({ a: 1, b: 2 })
   })
 
+  it('hasContent reflects position', () => {
+    const d = createDecoder(new Uint8Array([1, 2]))
+    expect(hasContent(d)).toBe(true)
+    readUint8(d)
+    readUint8(d)
+    expect(hasContent(d)).toBe(false)
+  })
+
+  it('clone preserves and overrides position', () => {
+    const d = createDecoder(new Uint8Array([1, 2, 3]))
+    readUint8(d)
+    const c1 = clone(d)
+    expect(c1.pos).toBe(1)
+    expect(c1.arr).toBe(d.arr)
+    const c2 = clone(d, 0)
+    expect(c2.pos).toBe(0)
+  })
+
+  it('skip8 advances one byte', () => {
+    const d = createDecoder(new Uint8Array([7, 8]))
+    skip8(d)
+    expect(d.pos).toBe(1)
+    expect(readUint8(d)).toBe(8)
+  })
+
+  it('readTailAsUint8Array returns remaining bytes', () => {
+    const d = createDecoder(new Uint8Array([1, 2, 3, 4]))
+    readUint8(d)
+    const tail = readTailAsUint8Array(d)
+    expect([...tail]).toEqual([2, 3, 4])
+  })
+
+  it('readVarUint throws on unexpected end of array', () => {
+    const d = createDecoder(new Uint8Array([0x80, 0x80]))
+    expect(() => readVarUint(d)).toThrow(/Unexpected end of array/)
+  })
+
+  it('readVarInt throws on unexpected end of array', () => {
+    const d = createDecoder(new Uint8Array([0x80]))
+    expect(() => readVarInt(d)).toThrow(/Unexpected end of array/)
+  })
+
+  it('readVarUint throws on integer out of range', () => {
+    const bytes = new Uint8Array(12).fill(0xFF)
+    bytes[11] = 0x7F
+    const d = createDecoder(bytes)
+    expect(() => readVarUint(d)).toThrow(/Integer out of Range/)
+  })
+
+  it('readVarInt throws on integer out of range', () => {
+    const bytes = new Uint8Array(12).fill(0xFF)
+    bytes[11] = 0x7F
+    const d = createDecoder(bytes)
+    expect(() => readVarInt(d)).toThrow(/Integer out of Range/)
+  })
+
+  describe('polyfill path', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals()
+      vi.resetModules()
+    })
+
+    it('readVarString via polyfill (empty, small, large)', async () => {
+      vi.stubGlobal('TextDecoder', undefined)
+      vi.resetModules()
+      const dec = await import('./decoding')
+      const enc = await import('./encoding')
+
+      const e = enc.createBinEncoder()
+      enc.writeVarString(e, '')
+      enc.writeVarString(e, 'abc')
+      const big = 'y'.repeat(15000)
+      enc.writeVarString(e, big)
+      const arr = enc.encodeToUint8Array(e)
+
+      const d = dec.createDecoder(arr)
+      expect(dec.readVarString(d)).toBe('')
+      expect(dec.readVarString(d)).toBe('abc')
+      expect(dec.readVarString(d)).toBe(big)
+    })
+  })
+
   it('should peek values', () => {
     const e = createBinEncoder()
     writeUint8(e, 42)

package/src/common/bin/lib0/encoding.spec.ts

@@ -1,4 +1,6 @@
-import { createBinEncoder, encodeToUint8Array, isNegativeZero, setUint8, setUint16, setUint32, writeAny, writeBigInt64, writeBigUint64, writeFloat32, writeFloat64, writeUint8, writeUint8Array, writeUint16, writeUint32, writeUint32BigEndian, writeVarInt, writeVarString, writeVarUint, writeVarUint8Array } from './encoding'
+import { afterEach, vi } from 'vitest'
+import { createDecoder, readAny, readVarInt as readVarIntDec, readVarString } from './decoding'
+import { createBinEncoder, encodeToUint8Array, isNegativeZero, length, setUint8, setUint16, setUint32, verifyLen, writeAny, writeBigInt64, writeBigUint64, writeBinaryEncoder, writeFloat32, writeFloat64, writeUint8, writeUint8Array, writeUint16, writeUint32, writeUint32BigEndian, writeVarInt, writeVarString, writeVarUint, writeVarUint8Array } from './encoding'
 
 describe('lib0/encoding', () => {
   it('should encode/decode uint8/16/32', () => {
@@ -84,4 +86,110 @@ describe('lib0/encoding', () => {
     expect(isNegativeZero(1)).toBe(false)
     expect(isNegativeZero(-1)).toBe(true)
   })
+
+  it('grows buffers when exceeding initial capacity', () => {
+    const e = createBinEncoder()
+    for (let i = 0; i < 250; i++) writeUint8(e, i & 0xFF)
+    expect(length(e)).toBe(250)
+    expect(e.bufs.length).toBeGreaterThan(0)
+    const arr = encodeToUint8Array(e)
+    expect(arr.length).toBe(250)
+    expect(arr[0]).toBe(0)
+    expect(arr[249]).toBe(249 & 0xFF)
+  })
+
+  it('verifyLen allocates a fresh buffer when required', () => {
+    const e = createBinEncoder()
+    writeUint8(e, 1)
+    verifyLen(e, 200)
+    expect(e.bufs.length).toBe(1)
+    writeUint8(e, 2)
+    const arr = encodeToUint8Array(e)
+    expect(arr[0]).toBe(1)
+    expect(arr[1]).toBe(2)
+  })
+
+  it('set updates bytes across multiple buffers', () => {
+    const e = createBinEncoder()
+    for (let i = 0; i < 250; i++) writeUint8(e, 0)
+    setUint8(e, 0, 0xAA)
+    setUint8(e, 120, 0xBB)
+    setUint8(e, 240, 0xCC)
+    const arr = encodeToUint8Array(e)
+    expect(arr[0]).toBe(0xAA)
+    expect(arr[120]).toBe(0xBB)
+    expect(arr[240]).toBe(0xCC)
+  })
+
+  it('writeUint8Array splits across buffers', () => {
+    const e = createBinEncoder()
+    writeUint8(e, 9)
+    const data = new Uint8Array(300)
+    for (let i = 0; i < data.length; i++) data[i] = i & 0xFF
+    writeUint8Array(e, data)
+    const arr = encodeToUint8Array(e)
+    expect(arr.length).toBe(301)
+    expect(arr[0]).toBe(9)
+    expect(arr[1]).toBe(0)
+    expect(arr[300]).toBe(299 & 0xFF)
+  })
+
+  it('writeBinaryEncoder appends another encoder', () => {
+    const inner = createBinEncoder()
+    writeUint8(inner, 1)
+    writeUint8(inner, 2)
+    const outer = createBinEncoder()
+    writeUint8(outer, 0)
+    writeBinaryEncoder(outer, inner)
+    const arr = encodeToUint8Array(outer)
+    expect([...arr]).toEqual([0, 1, 2])
+  })
+
+  it('writes long strings via alternate path', () => {
+    const e = createBinEncoder()
+    const big = 'z'.repeat(15000)
+    writeVarString(e, big)
+    const arr = encodeToUint8Array(e)
+    const d = createDecoder(arr)
+    expect(readVarString(d)).toBe(big)
+  })
+
+  it('writeVarInt handles multi-byte large values', () => {
+    const e = createBinEncoder()
+    writeVarInt(e, 1_000_000)
+    writeVarInt(e, -1_000_000)
+    const arr = encodeToUint8Array(e)
+    const d = createDecoder(arr)
+    expect(readVarIntDec(d)).toBe(1_000_000)
+    expect(readVarIntDec(d)).toBe(-1_000_000)
+  })
+
+  it('writeAny encodes float32-representable numbers compactly', () => {
+    const e = createBinEncoder()
+    writeAny(e, 0.5)
+    const arr = encodeToUint8Array(e)
+    expect(arr[0]).toBe(124)
+    const d = createDecoder(arr)
+    expect(readAny(d)).toBe(0.5)
+  })
+
+  describe('polyfill path', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals()
+      vi.resetModules()
+    })
+
+    it('writeVarString via polyfill when TextEncoder missing', async () => {
+      vi.stubGlobal('TextEncoder', undefined)
+      vi.stubGlobal('TextDecoder', undefined)
+      vi.resetModules()
+      const enc = await import('./encoding')
+      const dec = await import('./decoding')
+      const e = enc.createBinEncoder()
+      enc.writeVarString(e, 'hi✓')
+      const arr = enc.encodeToUint8Array(e)
+      const d = dec.createDecoder(arr)
+      expect(dec.readVarString(d)).toBe('hi✓')
+    })
+  })
 })

package/src/common/bin/lib0/string.spec.ts

@@ -1,4 +1,5 @@
-import { decodeUtf8, encodeUtf8, fromCamelCase, splice, trimLeft, utf8ByteLength } from './string'
+import { afterEach, vi } from 'vitest'
+import { _encodeUtf8Polyfill, decodeUtf8, encodeUtf8, fromCamelCase, splice, trimLeft, utf8ByteLength } from './string'
 
 describe('lib0/string', () => {
   it('should trim left', () => {
@@ -31,4 +32,47 @@ describe('lib0/string', () => {
     expect(splice('abcdef', 0, 3, 'Z')).toBe('Zdef')
     expect(splice('abcdef', 3, 0, 'Q')).toBe('abcQdef')
   })
+
+  it('should encode utf8 via polyfill', () => {
+    const bytes = _encodeUtf8Polyfill('hi✓')
+    expect(bytes).toBeInstanceOf(Uint8Array)
+    expect(decodeUtf8(bytes)).toBe('hi✓')
+  })
+
+  describe('polyfill paths via module reset', () => {
+    afterEach(() => {
+      vi.unstubAllGlobals()
+      vi.resetModules()
+    })
+
+    it('uses polyfill when TextEncoder/TextDecoder unavailable', async () => {
+      vi.stubGlobal('TextEncoder', undefined)
+      vi.stubGlobal('TextDecoder', undefined)
+      vi.resetModules()
+      const mod = await import('./string')
+      const encoded = mod.encodeUtf8('hello✓')
+      expect(encoded).toBeInstanceOf(Uint8Array)
+      expect(mod.decodeUtf8(encoded)).toBe('hello✓')
+      expect(mod.getUtf8TextEncoder()).toBeNull()
+    })
+
+    it('decodes via polyfill for a large buffer', async () => {
+      vi.stubGlobal('TextDecoder', undefined)
+      vi.resetModules()
+      const mod = await import('./string')
+      const big = 'a'.repeat(15000)
+      const bytes = new TextEncoder().encode(big)
+      expect(mod.decodeUtf8(bytes)).toBe(big)
+    })
+
+    it('disables broken TextDecoder (Safari BOM workaround)', async () => {
+      class FakeDecoder {
+        decode() { return 'x' }
+      }
+      vi.stubGlobal('TextDecoder', FakeDecoder as any)
+      vi.resetModules()
+      const mod = await import('./string')
+      expect(mod.getUtf8TextDecoder()).toBeNull()
+    })
+  })
 })

package/src/common/crypto/crypto.spec.ts

@@ -84,6 +84,13 @@ describe('crypto', () => {
     expect(typeof key).toBe('object')
   })
 
+  it('should derive keys without salt (default branch)', async () => {
+    const key = await deriveKeyPbkdf2(new Uint8Array([1, 2, 3]))
+    expect(key).toBeDefined()
+    const keyCbc = await (await import('./crypto')).deriveKeyPbkdf2CBC(new Uint8Array([1, 2, 3]))
+    expect(keyCbc).toBeDefined()
+  })
+
   it('should handle zero-length random and digest', async () => {
     expect(randomUint8Array(0)).toEqual(new Uint8Array(0))
     expect((await digest(new Uint8Array(0))).length).toBeGreaterThan(0)

package/src/common/crypto/xaes.spec.ts

@@ -80,6 +80,54 @@ describe('xaes.spec', () => {
     expect(new Uint8Array(decrypted)).toEqual(plaintext)
   })
 
+  it('xaes rejects wrong algorithm key', async () => {
+    const key = await crypto.subtle.generateKey(
+      { name: 'AES-GCM', length: 256 },
+      false,
+      ['encrypt', 'decrypt'],
+    )
+    const iv = new Uint8Array(24)
+    await expect(encryptXAES({ iv }, key, new Uint8Array(1))).rejects.toThrow(/AES-CBC/)
+  })
+
+  it('xaes rejects key without encrypt usage', async () => {
+    const key = await crypto.subtle.importKey(
+      'raw',
+      new Uint8Array(32).fill(0x05),
+      { name: 'AES-CBC', length: 256 },
+      false,
+      ['decrypt'],
+    )
+    const iv = new Uint8Array(24)
+    await expect(encryptXAES({ iv }, key, new Uint8Array(1))).rejects.toThrow(/encrypt/)
+  })
+
+  it('xaes rejects key of wrong length', async () => {
+    const key = await crypto.subtle.importKey(
+      'raw',
+      new Uint8Array(16).fill(0x06),
+      { name: 'AES-CBC', length: 128 },
+      false,
+      ['encrypt', 'decrypt'],
+    )
+    const iv = new Uint8Array(24)
+    await expect(encryptXAES({ iv }, key, new Uint8Array(1))).rejects.toThrow(/256 bits/)
+  })
+
+  it('xaes rejects iv of wrong length', async () => {
+    const key = await generateKeyXAES()
+    await expect(encryptXAES({ iv: new Uint8Array(12) }, key, new Uint8Array(1))).rejects.toThrow(/24 bytes/)
+  })
+
+  it('xaes accepts iv as ArrayBuffer', async () => {
+    const key = await generateKeyXAES()
+    const ivBuffer = new Uint8Array(24).fill(7).buffer
+    const data = new Uint8Array(10).fill(2)
+    const encrypted = await encryptXAES({ iv: ivBuffer }, key, data)
+    const decrypted = await decryptXAES({ iv: ivBuffer }, key, encrypted)
+    expect(new Uint8Array(decrypted)).toEqual(data)
+  })
+
   // it('xaes test vector, accumulated', async () => {
   //   const hash = new SHAKE128()
   //   const rng = new SHAKE128()

package/src/common/data/deep.spec.ts

@@ -174,6 +174,51 @@ describe('deep', () => {
   //   // expect(a.one.sample.a === b.one.sample.a).toBe(true)
   // })
 
+  it('deepEqual handles branch cases', () => {
+    expect(deepEqual(1, 2)).toBe(false)
+    expect(deepEqual(null, {})).toBe(false)
+    expect(deepEqual({}, null)).toBe(false)
+    class A { x = 1 }
+    class B { x = 1 }
+    expect(deepEqual(new A(), new B())).toBe(false)
+    expect(deepEqual({ a: 1 }, { b: 1 })).toBe(false)
+    expect(deepEqual({ a: 1 }, { a: 1, b: 2 })).toBe(false)
+    expect(deepEqual({ a: 1, b: 2 }, { a: 1, c: 2 })).toBe(false)
+    expect(deepEqual({ a: 1 }, { a: 1 })).toBe(true)
+
+    const proto = { inherited: 1 }
+    const x: any = Object.create(proto)
+    x.own = 1
+    const y: any = Object.create(proto)
+    y.own = 1
+    expect(deepEqual(x, y)).toBe(true)
+  })
+
+  it('deepStripUndefinedInPlace handles cycles and primitives', () => {
+    expect(deepStripUndefinedInPlace(5)).toBe(5)
+    const cyc: any = { a: 1 }
+    cyc.self = cyc
+    const result = deepStripUndefinedInPlace(cyc)
+    expect(result).toBe(cyc)
+    expect(cyc.a).toBe(1)
+    const obj: any = Object.create({ inherited: 1 })
+    obj.own = undefined
+    obj.keep = 2
+    deepStripUndefinedInPlace(obj)
+    expect('own' in obj).toBe(false)
+    expect(obj.keep).toBe(2)
+  })
+
+  it('deepMerge handles non-object target and source', () => {
+    expect(deepMerge(null as any, { a: 1 })).toEqual({ a: 1 })
+    expect(deepMerge({ a: 1 }, null)).toEqual({ a: 1 })
+    expect(deepMerge({ a: 1 }, 'str' as any)).toEqual({ a: 1 })
+  })
+
+  it('deepMerge concatenates arrays', () => {
+    expect(deepMerge({ list: [1, 2] }, { list: [3, 4] })).toEqual({ list: [1, 2, 3, 4] })
+  })
+
   it('should strip undefined', () => {
     const sample = {
       hello: {

package/src/common/data/regexp.spec.ts

@@ -0,0 +1,30 @@
+import { escapeRegExp } from './regexp'
+
+describe('escapeRegExp', () => {
+  it('returns empty string for falsy input', () => {
+    expect(escapeRegExp('')).toBe('')
+    // @ts-expect-error testing falsy
+    expect(escapeRegExp(undefined)).toBe('')
+    // @ts-expect-error testing falsy
+    expect(escapeRegExp(null)).toBe('')
+  })
+
+  it('returns source of RegExp input', () => {
+    expect(escapeRegExp(/foo\.bar/)).toBe('foo\\.bar')
+  })
+
+  it('escapes all special characters', () => {
+    expect(escapeRegExp('\\-[]/{}()*+?.^$|')).toBe('\\\\\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\^\\$\\|')
+  })
+
+  it('leaves normal characters alone', () => {
+    expect(escapeRegExp('hello world 123')).toBe('hello world 123')
+  })
+
+  it('escaped string works as literal in RegExp', () => {
+    const src = 'a.b+c'
+    const re = new RegExp(escapeRegExp(src))
+    expect(re.test('a.b+c')).toBe(true)
+    expect(re.test('axbxc')).toBe(false)
+  })
+})

package/src/common/schema/export-json-schema.spec.ts

@@ -171,11 +171,15 @@ describe('json-schema.spec', () => {
                   "type": "string",
                 },
                 "value": Object {
-                  "description": "The value to compare against",
-                  "type": Array [
-                    "string",
-                    "number",
+                  "anyOf": Array [
+                    Object {
+                      "type": "string",
+                    },
+                    Object {
+                      "type": "number",
+                    },
                   ],
+                  "description": "The value to compare against",
                 },
               },
               "required": Array [
@@ -233,9 +237,9 @@ describe('json-schema.spec', () => {
                 description: 'A comparison operator',
               },
               value: {
-                type: [
-                  'string',
-                  'number',
+                anyOf: [
+                  { type: 'string' },
+                  { type: 'number' },
                 ],
                 description: 'The value to compare against',
               },

package/src/common/schema/export-json-schema.ts

@@ -1,72 +1,79 @@
 import type { Type } from './schema'
 import { isEmpty } from '../data'
-import { objectMap } from '../data/object'
 
-const _mapJsonSchemaType: Record<string, string> = {
+const _primitiveMap: Record<string, string> = {
   string: 'string',
   number: 'number',
-  boolean: 'boolean',
   int: 'integer',
+  boolean: 'boolean',
 }
 
-export function schemaExportJsonSchema<T>(schema: Type<T>): Record<string, any> {
-  // assert(isSchemaObjectFlat(schema), 'schema should be a flat object')
+function transformSchema(schema: Type<any>): Record<string, any> {
+  const out: Record<string, any> = {}
 
-  function transformSchema(schema: Type<any>): any {
-    const type = _mapJsonSchemaType[schema.type] ?? schema.type ?? 'object'
+  if (schema._enumValues) {
+    out.type = _primitiveMap[schema.type] ?? schema.type
+    out.enum = [...schema._enumValues]
+  }
+  else if (schema.type === 'literal') {
+    out.const = schema._default
+  }
+  else if (schema.type === 'union' && Array.isArray(schema._union)) {
+    out.anyOf = schema._union.map((s: Type<any>) => transformSchema(s))
+  }
+  else if (schema.type === 'object' && schema._object) {
+    out.type = 'object'
     const properties: Record<string, any> = {}
     const required: string[] = []
-
-    objectMap(schema._object!, (key, schema: any) => {
-      const type = _mapJsonSchemaType[schema.type] ?? schema.type
-      properties[key] = { type }
-      const enumValues = (schema as any)._enumValues
-      if (enumValues) {
-        properties[key].enum = enumValues
-      }
-      if (schema._default !== undefined) {
-        properties[key].default = schema._default
-      }
-      if (schema._meta?.desc) {
-        properties[key].description = schema._meta.desc
-      }
-      if (schema._optional !== true) {
+    for (const key of Object.keys(schema._object)) {
+      const propSchema = schema._object[key] as Type<any>
+      properties[key] = transformSchema(propSchema)
+      if (propSchema._optional !== true)
         required.push(key)
-      }
-      if (schema.type === 'array' && schema._type) {
-        properties[key].items = transformSchema(schema._type)
-      }
-      else if (schema.type === 'object' && schema._object) {
-        Object.assign(properties[key], transformSchema(schema))
-        properties[key].additionalProperties = false
-      }
-      else if (schema.type === 'record' && schema._type) {
-        properties[key].type = 'object'
-        properties[key].additionalProperties = transformSchema(schema._type)
-      }
-      // Handle union types (e.g., z.union)
-      else if (schema.type === 'union' && Array.isArray(schema._union)) {
-        properties[key].type = schema._union.map((s: any) => _mapJsonSchemaType[s.type] ?? s.type) // todo complex types
-      }
-    })
-
-    if (!isEmpty(properties)) {
-      return {
-        type,
-        properties,
-        additionalProperties: false,
-        ...(required.length > 0 ? { required } : {}),
-      }
-    }
-
-    return {
-      type,
     }
+    if (!isEmpty(properties))
+      out.properties = properties
+    out.additionalProperties = false
+    if (required.length > 0)
+      out.required = required
   }
+  else if (schema.type === 'record' && schema._type) {
+    out.type = 'object'
+    out.additionalProperties = transformSchema(schema._type)
+  }
+  else if (schema.type === 'array' && schema._type) {
+    out.type = 'array'
+    out.items = transformSchema(schema._type)
+  }
+  else if (schema.type === 'tuple' && Array.isArray(schema._type)) {
+    out.type = 'array'
+    out.items = (schema._type as Type<any>[]).map(s => transformSchema(s))
+    out.minItems = schema._type.length
+    out.maxItems = schema._type.length
+  }
+  else if (schema.type === 'none') {
+    out.type = 'null'
+  }
+  else if (schema.type === 'any') {
+    // no constraint
+  }
+  else {
+    const t = _primitiveMap[schema.type]
+    if (t)
+      out.type = t
+  }
+
+  if (schema._default !== undefined && schema.type !== 'literal')
+    out.default = schema._default
+  if (schema._meta?.desc)
+    out.description = schema._meta.desc
 
+  return out
+}
+
+export function schemaExportJsonSchema<T>(schema: Type<T>): Record<string, any> {
   return {
     $schema: 'http://json-schema.org/draft-07/schema#',
-    additionalProperties: false,
     ...transformSchema(schema),
   }
 }

package/src/common/schema/_sandbox/sandbox-inherit.ts

@@ -1,13 +0,0 @@
-// class TypeClass<T = unknown> {
-//   optional(): TypeClass<T | undefined> {
-//     return this
-//   }
-// }
-
-// class TypeStringClass<T extends string> extends TypeClass<T> {
-
-// }
-
-// const o = new TypeStringClass()
-// const v = o.optional()
-// type t = typeof v // expect: TypeStringClass<string | undefined>

package/src/common/schema/_sandbox/sandbox.ts

@@ -1,42 +0,0 @@
-// // Function
-
-// interface Type<T = unknown> {
-//   _value?: T
-// }
-
-// type Infer<T> = T extends Type<infer TT> ? TT : never
-
-// type TupleOutput<T extends Type[]> = {
-//   [K in keyof T]: T[K] extends Type<infer U> ? U : never;
-// }
-
-// type ArrayOutput<Head extends Type[], Rest extends Type | undefined> = [
-//   ...TupleOutput<Head>,
-//   ...(Rest extends Type ? Infer<Rest>[] : []),
-// ]
-
-// type ArrayType<
-//   Head extends Type[] = Type[],
-//   Rest extends Type | undefined = Type | undefined,
-// > = Type<ArrayOutput<Head, Rest>>
-
-// function tuple<T extends [] | [Type, ...Type[]]>(items: T): ArrayType<T, undefined> {
-//   return {} as any
-// }
-
-// function string(): Type<string> {
-//   return {} as any
-// }
-
-// function boolean(): Type<boolean> {
-//   return {} as any
-// }
-
-// function number(): Type<number> {
-//   return {} as any
-// }
-
-// const tt = tuple([number(), string(), boolean()])
-// type ttt = Infer<typeof tt> // expected [number, string, boolean]
-
-// //