type-plus 7.6.2 → 8.0.0-beta.10

package/ts/object/pick.ts

@@ -1,220 +0,0 @@
-import type { UnionKeys } from '../union_keys.js'
-import type { AnyRecord } from './AnyRecord.js'
-import { record } from './record.js'
-import { reduceByKey } from './reduceKey.js'
-
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>>(subject: T, prop1: P1): Pick<T, P1>
-export function pick<T extends AnyRecord, P1 extends UnionKeys<T>, P2 extends UnionKeys<T>>(
-	subject: T,
-	prop1: P1,
-	prop2: P2
-): Pick<T, P1 | P2>
-export function pick<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>
->(subject: T, prop1: P1, prop2: P2, prop3: P3): Pick<T, P1 | P2 | P3>
-export function pick<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>,
-	P4 extends UnionKeys<T>
->(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4): Pick<T, P1 | P2 | P3 | P4>
-export function pick<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>,
-	P4 extends UnionKeys<T>,
-	P5 extends UnionKeys<T>
->(subject: T, prop1: P1, prop2: P2, prop3: P3, prop4: P4, prop5: P5): Pick<T, P1 | P2 | P3 | P4 | P5>
-export function pick<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>,
-	P4 extends UnionKeys<T>,
-	P5 extends UnionKeys<T>,
-	P6 extends UnionKeys<T>
->(
-	subject: T,
-	prop1: P1,
-	prop2: P2,
-	prop3: P3,
-	prop4: P4,
-	prop5: P5,
-	prop6: P6
-): Pick<T, P1 | P2 | P3 | P4 | P5 | P6>
-export function pick<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>,
-	P4 extends UnionKeys<T>,
-	P5 extends UnionKeys<T>,
-	P6 extends UnionKeys<T>,
-	P7 extends UnionKeys<T>
->(
-	subject: T,
-	prop1: P1,
-	prop2: P2,
-	prop3: P3,
-	prop4: P4,
-	prop5: P5,
-	prop6: P6,
-	prop7: P7
-): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7>
-export function pick<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>,
-	P4 extends UnionKeys<T>,
-	P5 extends UnionKeys<T>,
-	P6 extends UnionKeys<T>,
-	P7 extends UnionKeys<T>,
-	P8 extends UnionKeys<T>
->(
-	subject: T,
-	prop1: P1,
-	prop2: P2,
-	prop3: P3,
-	prop4: P4,
-	prop5: P5,
-	prop6: P6,
-	prop7: P7,
-	prop8: P8
-): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8>
-export function pick<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>,
-	P4 extends UnionKeys<T>,
-	P5 extends UnionKeys<T>,
-	P6 extends UnionKeys<T>,
-	P7 extends UnionKeys<T>,
-	P8 extends UnionKeys<T>,
-	P9 extends UnionKeys<T>
->(
-	subject: T,
-	prop1: P1,
-	prop2: P2,
-	prop3: P3,
-	prop4: P4,
-	prop5: P5,
-	prop6: P6,
-	prop7: P7,
-	prop8: P8,
-	prop9: P9
-): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9>
-export function pick<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>,
-	P4 extends UnionKeys<T>,
-	P5 extends UnionKeys<T>,
-	P6 extends UnionKeys<T>,
-	P7 extends UnionKeys<T>,
-	P8 extends UnionKeys<T>,
-	P9 extends UnionKeys<T>,
-	P10 extends UnionKeys<T>
->(
-	subject: T,
-	prop1: P1,
-	prop2: P2,
-	prop3: P3,
-	prop4: P4,
-	prop5: P5,
-	prop6: P6,
-	prop7: P7,
-	prop8: P8,
-	prop9: P9,
-	prop10: P10
-): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10>
-export function pick<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>,
-	P4 extends UnionKeys<T>,
-	P5 extends UnionKeys<T>,
-	P6 extends UnionKeys<T>,
-	P7 extends UnionKeys<T>,
-	P8 extends UnionKeys<T>,
-	P9 extends UnionKeys<T>,
-	P10 extends UnionKeys<T>,
-	P11 extends UnionKeys<T>
->(
-	subject: T,
-	prop1: P1,
-	prop2: P2,
-	prop3: P3,
-	prop4: P4,
-	prop5: P5,
-	prop6: P6,
-	prop7: P7,
-	prop8: P8,
-	prop9: P9,
-	prop10: P10,
-	prop11: P11
-): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11>
-export function pick<
-	T extends AnyRecord,
-	P1 extends UnionKeys<T>,
-	P2 extends UnionKeys<T>,
-	P3 extends UnionKeys<T>,
-	P4 extends UnionKeys<T>,
-	P5 extends UnionKeys<T>,
-	P6 extends UnionKeys<T>,
-	P7 extends UnionKeys<T>,
-	P8 extends UnionKeys<T>,
-	P9 extends UnionKeys<T>,
-	P10 extends UnionKeys<T>,
-	P11 extends UnionKeys<T>,
-	P12 extends UnionKeys<T>
->(
-	subject: T,
-	prop1: P1,
-	prop2: P2,
-	prop3: P3,
-	prop4: P4,
-	prop5: P5,
-	prop6: P6,
-	prop7: P7,
-	prop8: P8,
-	prop9: P9,
-	prop10: P10,
-	prop11: P11,
-	prop12: P12
-): Pick<T, P1 | P2 | P3 | P4 | P5 | P6 | P7 | P8 | P9 | P10 | P11 | P12>
-export function pick<T extends AnyRecord, Props extends UnionKeys<T>>(
-	subject: T,
-	...props: Props[]
-): Pick<T, Props>
-export function pick<T extends AnyRecord>(subject: T, ...props: Array<UnionKeys<T>>) {
-	return reduceByKey(
-		subject,
-		(p, k) => {
-			if (props.indexOf(k) >= 0) p[k] = subject[k]
-			return p
-		},
-		Object.getPrototypeOf(subject) === null ? record() : {}
-	)
-}
-
-/**
- * Pick properties `K` from `T`.
- * Works with union.
- *
- * Original type by Titian Cernicova-Dragomir
- * @see <https://github.com/microsoft/TypeScript/issues/28339#issuecomment-463577347>
- */
-export type Pick<T, K extends UnionKeys<T>> = T extends unknown ? Pick._<T, keyof T & K> : never
-
-export namespace Pick {
-	export type _<T, K extends keyof T> = { [P in K]: T[P] }
-}

package/ts/object/properties.ts

@@ -1,4 +0,0 @@
-/**
- * Gets the properties of an object type.
- */
-export type Properties<T> = { [k in keyof T]: T[k] } // & {}

package/ts/object/readme.md

@@ -1,65 +0,0 @@
-# object
-
-## Type Checking
-
-The `ObjectType<T>` and friends are used to check if a type is `object` or object types.
-
-Note that `Function` are also considered `object` in TypeScript.
-
-```ts
-import type { ObjectType } from 'type-plus'
-
-type R = ObjectType<object> // object
-type R = ObjectType<{}> // {}
-type R = ObjectType<{ a: number }> // { a: number }
-
-type R = ObjectType<1> // never
-```
-
-- [`ObjectType<T, Then = T, Else = never>`](object_type.ts#L16): check if `T` is `object`.
-- [`IsObject<T, Then = true, Else = false`](object_type.ts#L33): is `T` `object`.
-- [`NotObjectType<T, Then = T, Else = never>`](object_type.ts#L48): check if `T` is not `object`.
-- [`IsNotObject<T, Then = true, Else = false>`](object_type.ts#L65): is `T` not `object`.
-
-## IsOptionalKey
-
-> `IsOptionalKey<T, K, Then = true, Else = false>`
-
-Validate if the key `K` in `T` is optional.
-
-```ts
-import type { IsOptionalKey } from 'type-plus'
-
-type R = IsOptionalKey<{ a?: number }, 'a'> // true
-type R = IsOptionalKey<{ a: number }, 'a'> // false
-```
-
-## OptionalKeys
-
-> `OptionalKeys<T>`
-
-Gets the optional keys of `T`.
-
-```ts
-import type { OptionalKeys } from 'type-plus'
-
-type R = OptionalKeys<{ a?: number; b: string }> // 'a'
-```
-
-## OptionalProps
-
-> `OptionalProps<T>`
-
-Gets the optional properties of `T`.
-
-```ts
-import type { OptionalProps } from 'type-plus'
-
-type R = OptionalProps<{ a?: number; b: string }> // { a?: number }
-```
-
-## References
-
-- [Handbook]
-
-[handbook]: https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#object-types

package/ts/object/record.ts

@@ -1,23 +0,0 @@
-import type { Widen } from '../utils/index.js'
-import type { AnyRecord } from './AnyRecord.js'
-import type { KeyTypes } from './KeyTypes.js'
-
-/**
- * Creates a `Record<Key, Value>` or your custom record.
- * By default,
- * `record()` will widen the keys (`K`) you specified in the `value` to form `Record<Widen<K>, V>`.
- *
- * You can also override it by specifying a custom record, e.g.:
- * `record<{ a: number }>()`
- */
-export function record<K extends KeyTypes, V>(value?: Record<K, V>): Record<Widen<K>, V>
-export function record<R extends Record<any, any>>(value?: R): R
-export function record(value?: any) {
-	const r = Object.create(null) as AnyRecord
-	return (value ? Object.assign(r, value) : r) as AnyRecord
-}
-
-/**
- * Gets the value type `T` from `Record<any, T>`.
- */
-export type RecordValue<R extends Record<any, any>> = R extends Record<any, infer T> ? T : never

package/ts/object/recursive_partial.ts

@@ -1,39 +0,0 @@
-// Source: https://stackoverflow.com/questions/41980195/recursive-partialt-in-typescript-2-1
-
-import type { AnyFunction } from '../function/any_function.js'
-import type { ExtractFunction } from '../index.js'
-import type { AnyRecord } from './AnyRecord.js'
-import type { Properties } from './properties.js'
-
-/**
- * Creates a recursive partial type of type T.
- *
- * @example
- * ```ts
- * interface Foo {
- *   bar: number;
- *   baz: {
- *     qux: string
- *   }
- * }
- *
- * type PartialFoo = RecursivePartial<Foo>
- * // {
- * //   bar?: number | undefined;
- * //   baz?: {
- * //     qux?: string | undefined
- * //   } | undefined
- * // }
- * ```
- */
-export type RecursivePartial<T> = {
-	[P in keyof T]?: T[P] extends (infer U)[]
-		? RecursivePartial<U>[] | undefined
-		: T[P] extends infer F extends AnyFunction
-		? [keyof T[P]] extends [undefined]
-			? T[P] | undefined
-			: ExtractFunction<F> & RecursivePartial<Properties<T[P]>>
-		: T[P] extends AnyRecord
-		? RecursivePartial<T[P]> | undefined
-		: T[P] | undefined
-}

package/ts/object/reduceKey.ts

@@ -1,14 +0,0 @@
-import type { KeyTypes } from './KeyTypes.js'
-
-export function reduceByKey<S extends Record<KeyTypes, any>, T>(
-	subject: S,
-	callbackfn: (previousValue: T, key: keyof S, currentIndex: number, array: string[], subject: S) => T,
-	initialValue: T
-): T {
-	return Object.keys(subject).reduce((p, k, i, a) => callbackfn(p, k, i, a, subject), initialValue)
-}
-
-/**
- * @deprecated renamed to reduceByKey
- */
-export const reduceKey = reduceByKey

package/ts/object/replaceProperty.ts

@@ -1,11 +0,0 @@
-import type { AnyRecord } from './AnyRecord.js'
-
-export type ReplaceProperty<T extends AnyRecord, K extends keyof T, V> = Omit<T, K> & { [P in K]: V }
-
-export function replaceProperty<T extends AnyRecord, K extends keyof T, V>(
-	subject: T,
-	key: K,
-	value: V
-): ReplaceProperty<T, K, V> {
-	return { ...subject, [key]: value }
-}

package/ts/object/someKey.ts

@@ -1,11 +0,0 @@
-import type { KeyTypes } from './KeyTypes.js'
-
-export function someKey<S extends Record<KeyTypes, any>, T = any>(
-	subject: S,
-	predicate: (this: T, key: keyof S, index: number, array: string[], subject: S) => unknown,
-	thisArg?: T
-): boolean {
-	return Object.keys(subject).some(function (this: T, k, i, a) {
-		return predicate.apply(this, [k, i, a, subject])
-	}, thisArg)
-}

package/ts/object/split.ts

@@ -1,203 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import type { AnyRecord } from './AnyRecord.js'
-import type { Omit } from './omit.js'
-import { reduceByKey } from './reduceKey.js'
-import type { Partial } from './Partial.js'
-import type { NonUndefined } from '../utils/NonUndefined.js'
-
-type Splitter<T extends AnyRecord> = Partial<{ [k in keyof T]: T[k] | undefined }>
-export type Split<T extends AnyRecord, S extends AnyRecord> = {
-	[k in keyof S]-?: S[k] extends undefined ? T[k] : NonNullable<T[k]> | NonUndefined<S[k]>
-}
-
-/**
- * Split an object into multiple objects.
- * @returns [...entries, remaining]
- */
-export function split<T extends AnyRecord, S1 extends Splitter<T>>(
-	target: T,
-	split1: S1
-): [Split<T, S1>, Omit<T, keyof S1>]
-export function split<T extends AnyRecord, S1 extends Splitter<T>, S2 extends Splitter<T>>(
-	target: T,
-	split1: S1,
-	split2: S2
-): [Split<T, S1>, Split<T, S2>, Omit<T, keyof S1 | keyof S2>]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3
-): [Split<T, S1>, Split<T, S2>, Split<T, S3>, Omit<T, keyof S1 | keyof S2 | keyof S3>]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>,
-	S7 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6,
-	splitter7: S7
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Split<T, S7>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>,
-	S7 extends Splitter<T>,
-	S8 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6,
-	splitter7: S7,
-	splitter8: S8
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Split<T, S7>,
-	Split<T, S8>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7 | keyof S8>
-]
-export function split<
-	T extends AnyRecord,
-	S1 extends Splitter<T>,
-	S2 extends Splitter<T>,
-	S3 extends Splitter<T>,
-	S4 extends Splitter<T>,
-	S5 extends Splitter<T>,
-	S6 extends Splitter<T>,
-	S7 extends Splitter<T>,
-	S8 extends Splitter<T>,
-	S9 extends Splitter<T>
->(
-	target: T,
-	splitter1: S1,
-	splitter2: S2,
-	splitter3: S3,
-	splitter4: S4,
-	splitter5: S5,
-	splitter6: S6,
-	splitter7: S7,
-	splitter8: S8,
-	splitter9: S9
-): [
-	Split<T, S1>,
-	Split<T, S2>,
-	Split<T, S3>,
-	Split<T, S4>,
-	Split<T, S5>,
-	Split<T, S6>,
-	Split<T, S7>,
-	Split<T, S8>,
-	Split<T, S9>,
-	Omit<T, keyof S1 | keyof S2 | keyof S3 | keyof S4 | keyof S5 | keyof S6 | keyof S7 | keyof S8 | keyof S9>
-]
-export function split(target: AnyRecord, ...splitters: AnyRecord[]): AnyRecord[] {
-	const keyMap: AnyRecord = {}
-	const s = splitters.map(s =>
-		reduceByKey(s, (p, k) => ((keyMap[k] = true), (p[k] = target[k] ?? s[k]), p), {} as AnyRecord)
-	)
-	const r = reduceByKey(target, (p, k) => (keyMap[k] ? p : ((p[k] = target[k]), p)), {} as AnyRecord)
-	return [...s, r]
-}

package/ts/object/typeOverrideIncompatible.ts

@@ -1,10 +0,0 @@
-import type { ANotB, AnyRecord } from './index.js'
-
-export function typeOverrideIncompatible<A extends AnyRecord>() {
-	return function <B extends AnyRecord>(source: B, override: ANotB<A, B>): A {
-		return {
-			...source,
-			...override
-		}
-	}
-}

package/ts/predicates/CanAssign.ts

@@ -1,71 +0,0 @@
-import type { NotExtendable } from './Extends.js'
-import type { IsEmptyObject } from './IsEmptyObject.js'
-
-/**
- * Can `A` assign to `B`
- *
- * Note that when union is involved, the assignability is measured distributively.
- * Meaning the result can be `Then | Else` (i.e. `boolean` by default),
- * instead of distinctive `Then` (`true`) or `Else` (`false`).
- *
- * This is the correct behavior.
- *
- * @example
- * ```ts
- * CanAssign<number | string, number> // boolean
- * ```
- *
- * We are checking can `A` assign to `B`.
- * Since `A` is `number | string`,
- * `A` can assign to `B` when `A` is number` (true), and
- * `A` cannot assign to `B` when `A` is string` (false).
- * So the result is `true | false = boolean`.
- *
- * If you want to make sure all branches are assignable,
- * use `StrictCanAssign<A, B>`.
- */
-export type CanAssign<A, B, Then = true, Else = false> = IsEmptyObject<A> extends true
-	? Record<string, unknown> extends B
-		? Then
-		: Else
-	: boolean extends A
-	? boolean extends B
-		? Then
-		: Else
-	: A extends B
-	? Then
-	: Else
-
-/**
- * Can `A` strictly assign to `B`.
- *
- * All branches in an union `A` are assignable to `B`.
- *
- * @example
- * ```ts
- * StrictCanAssign<number | string, number> // false
- * StrictCanAssign<number | string, number | string> // true
- * ```
- */
-export type StrictCanAssign<A, B, Then = true, Else = false> = IsEmptyObject<A> extends true
-	? Record<string, unknown> extends B
-		? Then
-		: Else
-	: boolean extends A
-	? boolean extends B
-		? Then
-		: Else
-	: [A] extends [B]
-	? Then
-	: Else
-
-/**
- * @deprecated use `CanAssign` instead
- */
-export type IsAssign<A, B, Then = true, Else = false> = CanAssign<A, B, Then, Else>
-
-export function canAssign<T>(canAssign: false): <S>(subject: NotExtendable<S, T>) => true
-export function canAssign<T>(): <S extends T>(subject: S) => CanAssign<S, T>
-export function canAssign<T>(): <S extends T>(subject: S) => any {
-	return () => true
-}

package/ts/predicates/Extends.ts

@@ -1,4 +0,0 @@
-export type Extendable<A, B, Then = A, Else = never> = A extends B ? Then : Else
-export type NotExtendable<A, B, Then = A, Else = never> = A extends B ? Else : Then
-export type IsExtend<A, B, Then = true, Else = false> = A extends B ? Then : Else
-export type IsNotExtend<A, B, Then = true, Else = false> = A extends B ? Else : Then

package/ts/predicates/index.ts

@@ -1,7 +0,0 @@
-export * from './CanAssign.js'
-export type { Extendable, IsExtend, IsNotExtend, NotExtendable } from './Extends.js'
-export type { If } from './If.js'
-export type { IsEmptyObject } from './IsEmptyObject.js'
-export type { IsLiteral } from './literal.js'
-export type { And, Not, Or, Xor } from './logical.js'
-