Workaround for if globalThis is not defined.

Array/Class.ts

@@ -2,6 +2,7 @@ import { Base } from "../Base"
 import { Flaw } from "../Flaw"
 import type { isly } from "../index"
 import { Name } from "../Name"
+import { system } from "../system"
 import { Restriction } from "./Restriction"
 
 export class Class<V> extends Base<V[]> {
@@ -18,7 +19,7 @@ export class Class<V> extends Base<V[]> {
 		this._name = name
 	}
 	override is(value: V[] | any): value is V[] {
-		return globalThis.Array.isArray(value) && value.every(this.base.is.bind(this.base))
+		return system.Array.isArray(value) && value.every(this.base.is.bind(this.base))
 	}
 	override flawed(value: V[] | any): Flaw | false {
 		const result: Flaw | false = super.flawed(value)

Intersection/Class.ts

@@ -2,6 +2,7 @@ import { Base } from "../Base"
 import { Flaw } from "../Flaw"
 import type { isly } from "../index"
 import { Name } from "../Name"
+import { system } from "../system"
 
 export class Class<V = unknown, B extends Base<V> = Base<V>> extends Base<V> {
 	readonly class = "intersection"
@@ -67,11 +68,11 @@ function merge<T, S>(target: T, source: S): T & S {
 	return Array.isArray(target) && Array.isArray(source)
 		? (target.map((item, index) => merge(item, source[index])) as S & T)
 		: target && typeof target == "object" && source && typeof source == "object"
-		? globalThis.Object.fromEntries([
-				...globalThis.Object.entries(target),
-				...globalThis.Object.entries(source).map(([key, value]) => [
+		? system.Object.fromEntries([
+				...system.Object.entries(target),
+				...system.Object.entries(source).map(([key, value]) => [
 					key,
-					globalThis.Object.getOwnPropertyDescriptor(target, key) &&
+					system.Object.getOwnPropertyDescriptor(target, key) &&
 					typeof target[key as keyof typeof target] == "object" &&
 					typeof value == "object"
 						? merge(target[key as keyof typeof target], value)

Number/Class.ts

@@ -1,5 +1,6 @@
 import { Base } from "../Base"
 import type { isly } from "../index"
+import { system } from "../system"
 import { Restriction } from "./Restriction"
 
 export class Class<V extends number> extends Base<V> {
@@ -12,7 +13,7 @@ export class Class<V extends number> extends Base<V> {
 		super()
 	}
 	is(value: V | any): value is V {
-		return typeof value == "number" && globalThis.Number.isFinite(value)
+		return typeof value == "number" && system.Number.isFinite(value)
 	}
 	override restrict(...restriction: Restriction | Base.Restriction) {
 		return super.restrict(...(Base.Restriction.is(restriction) ? restriction : Restriction.convert(restriction)))

Number/Restriction.ts

@@ -1,5 +1,6 @@
 import { Base } from "../Base"
 import { Name } from "../Name"
+import { system } from "../system"
 import { Verifier } from "../Verifier"
 
 export type Restriction<V extends number = number> =
@@ -27,7 +28,7 @@ export namespace Restriction {
 	}
 	export function getVerifier<T extends number = number>(...[category, ...restriction]: Restriction<T>): Verifier<T> {
 		const verifiers: Record<Restriction.Category, (value: T) => boolean> = {
-			integer: globalThis.Number.isInteger,
+			integer: system.Number.isInteger,
 			positive: value => value > 0,
 			negative: value => value < 0,
 			minimum: value => value >= (restriction[0] as number),

Object/Class.ts

@@ -2,6 +2,7 @@ import { Base } from "../Base"
 import { BindResult } from "../BindResult"
 import { Flaw } from "../Flaw"
 import type { isly } from "../index"
+import { system } from "../system"
 import type { Type } from "../Type"
 import { Properties } from "./Properties"
 
@@ -13,7 +14,7 @@ export class Class<V extends object = Record<string, any>> extends Base<V> {
 	}
 	override get definition(): isly.Definition {
 		return Object.assign(super.definition, {
-			properties: globalThis.Object.fromEntries(Properties.entries(this.properties).map(([p, t]) => [p, t.definition])),
+			properties: system.Object.fromEntries(Properties.entries(this.properties).map(([p, t]) => [p, t.definition])),
 		})
 	}
 	private constructor(readonly properties: Properties<V>, name?: string) {
@@ -25,7 +26,7 @@ export class Class<V extends object = Record<string, any>> extends Base<V> {
 			!!value &&
 			typeof value == "object" &&
 			!Array.isArray(value) &&
-			globalThis.Object.entries<Base>(this.properties).every(([property, type]) => type.is(value[property]))
+			system.Object.entries<Base>(this.properties).every(([property, type]) => type.is(value[property]))
 		)
 	}
 	override prune(value: V | any): V | undefined {
@@ -95,10 +96,10 @@ export class Class<V extends object = Record<string, any>> extends Base<V> {
 }
 export namespace Class {
 	export function omit<T extends globalThis.Object, K extends keyof T>(object: T, omits: readonly K[]): Omit<T, K> {
-		const keys = globalThis.Object.keys(object).filter(k => omits.every(omit => omit != k)) as Exclude<keyof T, K>[]
+		const keys = system.Object.keys(object).filter(k => omits.every(omit => omit != k)) as Exclude<keyof T, K>[]
 		return pick(object, keys)
 	}
 	export function pick<T extends globalThis.Object, K extends keyof T>(object: T, picks: readonly K[]): Pick<T, K> {
-		return globalThis.Object.fromEntries(picks.map(key => [key, object[key]])) as Pick<T, K>
+		return system.Object.fromEntries(picks.map(key => [key, object[key]])) as Pick<T, K>
 	}
 }

Object/Properties.ts

@@ -1,27 +1,28 @@
 import { Base } from "../Base"
 import { Name } from "../Name"
+import { system } from "../system"
 
 export type Properties<T extends object> = {
 	[P in keyof T]: Base<T[P]>
 }
 export namespace Properties {
 	export function entries<T extends object>(properties: Properties<T>): [keyof T, Base<T[keyof T]>][] {
-		return globalThis.Object.entries<Base>(properties) as [keyof T, Base<T[keyof T]>][]
+		return system.Object.entries<Base>(properties) as [keyof T, Base<T[keyof T]>][]
 	}
 	export function getName(properties: Properties<any>): Name {
 		return `{ ${Properties.entries(properties)
 			.map(([p, t]) => `${p.toString()}: ${t.name}`)
 			.join(", ")} }`
 	}
 	export function prune<T extends object>(properties: Properties<T>, value: T): T {
-		return globalThis.Object.fromEntries(
+		return system.Object.fromEntries(
 			Properties.entries(properties)
 				.map(([p, t]) => [p, t.prune(value[p])])
 				.filter(([p, v]) => v !== undefined)
 		) as T
 	}
 	export function optional<T extends object>(properties: Properties<T>): Properties<Partial<T>> {
-		return globalThis.Object.fromEntries(
+		return system.Object.fromEntries(
 			Properties.entries(properties).map(([p, t]) => [p, t.optional()])
 		) as unknown as Properties<Partial<T>>
 	}

Record/index.spec.ts

@@ -1,4 +1,5 @@
 import { isly } from "../index"
+import { system } from "../system"
 
 describe("isly.record()", () => {
 	// compile error if not working
@@ -106,7 +107,7 @@ describe("isly.record()", () => {
 	it("record.prune", () => {
 		type User = { email: string }
 		const userRecordType = isly.record(isly.string(), isly.object<User>({ email: isly.string() }))
-		const usersRecords: Record<string, User> = globalThis.Object.fromEntries(
+		const usersRecords: Record<string, User> = system.Object.fromEntries(
 			[...Array(5).keys()].map(id => [`${id}`, { email: `${id}@example.com`, password: "shouldBeSecret" }])
 		)
 		expect(userRecordType.is(usersRecords)).toBe(true)

Tuple/Class.ts

@@ -2,6 +2,7 @@ import { Base } from "../Base"
 import { Flaw } from "../Flaw"
 import type { isly } from "../index"
 import { Name } from "../Name"
+import { system } from "../system"
 
 export class Class<V extends any[] = unknown[]> extends Base<V> {
 	readonly class = "tuple"
@@ -18,7 +19,7 @@ export class Class<V extends any[] = unknown[]> extends Base<V> {
 	}
 	override is(value: V | any): value is V {
 		return (
-			globalThis.Array.isArray(value) &&
+			system.Array.isArray(value) &&
 			value.length == this.base.length &&
 			this.base.every((type, index) => type.is(value[index]))
 		)

system.ts

@@ -0,0 +1,49 @@
+export const system = globalThis
+for (const name of [
+	"Atomics",
+	"AggregateError",
+	"Array",
+	"ArrayBuffer",
+	"BigInt",
+	"BigInt64Array",
+	"BigUint64Array",
+	"Boolean",
+	"Date",
+	"DataView",
+	"Error",
+	"EvalError",
+	"FinalizationRegistry",
+	"Float32Array",
+	"Float64Array",
+	"Function",
+	"Int8Array",
+	"Int16Array",
+	"Int32Array",
+	"Intl",
+	"JSON",
+	"Map",
+	"Math",
+	"Number",
+	"Object",
+	"Promise",
+	"Proxy",
+	"RangeError",
+	"Reflect",
+	"RegExp",
+	"ReferenceError",
+	"Set",
+	"SharedArrayBuffer",
+	"String",
+	"Symbol",
+	"SyntaxError",
+	"TypeError",
+	"Uint8Array",
+	"Uint8ClampedArray",
+	"Uint16Array",
+	"Uint32Array",
+	"URIError",
+	"WeakMap",
+	"WeakRef",
+	"WeakSet",
+] as const)
+	(system as any)[name] ??= globalThis[name]