atom.io 0.38.2 → 0.39.1

package/src/internal/is-fn.ts

@@ -0,0 +1,9 @@
+import type { Fn } from "./utility-types"
+
+const NON_CTOR_FN_REGEX =
+	/^\[object (?:Async|Generator|AsyncGenerator)?Function\]$/
+
+export function isFn(input: unknown): input is Fn {
+	const protoString = Object.prototype.toString.call(input)
+	return NON_CTOR_FN_REGEX.test(protoString)
+}

package/src/internal/junction.ts

@@ -1,25 +1,26 @@
 import type { Json } from "atom.io/json"
 
+import { MapOverlay, RelationsOverlay, SetOverlay } from "./overlays"
 import type { Refinement } from "./utility-types"
 
 export type JunctionEntriesBase<
-	AType extends string,
-	BType extends string,
+	A extends string,
+	B extends string,
 	Content extends Json.Object | null,
 > = {
-	readonly relations: ([AType, BType[]] | [BType, AType[]])[]
+	readonly relations: ([A, B[]] | [B, A[]])[]
 	readonly contents: [string, Content][]
 }
 export interface JunctionEntries<
-	AType extends string,
-	BType extends string,
+	A extends string,
+	B extends string,
 	Content extends Json.Object | null,
 > extends Json.Object,
-		JunctionEntriesBase<AType, BType, Content> {}
+		JunctionEntriesBase<A, B, Content> {}
 
-export type JunctionSchemaBase<ASide extends string, BSide extends string> = {
+export type JunctionSchemaBase<AName extends string, BName extends string> = {
 	/** Description of the relationship between the two sides */
-	readonly between: [a: ASide, b: BSide]
+	readonly between: [a: AName, b: BName]
 	/** How many relations are allowed in each direction? */
 	readonly cardinality: `1:1` | `1:n` | `n:n`
 }
@@ -55,58 +56,58 @@ export type ExternalStoreConfiguration<Content extends Json.Object | null> =
 				Empty<ExternalStoreWithContentConfiguration<Json.Object>>
 
 export type JunctionAdvancedConfiguration<
-	AType extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B extends string,
 	Content extends Json.Object | null,
 > = {
 	warn?: (...args: any[]) => void
 	externalStore?: ExternalStoreConfiguration<Content>
-	isAType?: Refinement<string, AType>
-	isBType?: Refinement<string, BType>
+	isAType?: Refinement<string, A>
+	isBType?: Refinement<string, B>
 	isContent?: Refinement<unknown, Content>
-	makeContentKey?: (a: AType, b: BType) => string
+	makeContentKey?: (a: A, b: B) => string
+	source?: Junction<AName, A, BName, B, Content>
 }
 
 export type JunctionJSON<
-	ASide extends string,
-	AType extends string,
-	BSide extends string,
-	BType extends string,
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B extends string,
 	Content extends Json.Object | null,
-> = JunctionEntries<AType, BType, Content> & JunctionSchema<ASide, BSide>
+> = JunctionEntries<A, B, Content> & JunctionSchema<AName, BName>
 
 export class Junction<
-	const ASide extends string,
-	const AType extends string,
-	const BSide extends string,
-	const BType extends string,
+	const AName extends string,
+	const A extends string,
+	const BName extends string,
+	const B extends string,
 	const Content extends Json.Object | null = null,
 > {
-	public readonly a: ASide
-	public readonly b: BSide
+	public readonly a: AName
+	public readonly b: BName
 	public readonly cardinality: `1:1` | `1:n` | `n:n`
-	public readonly relations: Map<AType | BType, Set<AType> | Set<BType>> =
-		new Map()
+	public readonly relations: Map<A | B, Set<A> | Set<B>> = new Map()
 	public readonly contents: Map<string, Content> = new Map()
 
-	public isAType?: Refinement<string, AType> | null
-	public isBType?: Refinement<string, BType> | null
+	public isAType?: Refinement<string, A> | null
+	public isBType?: Refinement<string, B> | null
 	public isContent: Refinement<unknown, Content> | null
-	public makeContentKey = (a: AType, b: BType): string => `${a}:${b}`
+	public makeContentKey = (a: A, b: B): string => `${a}:${b}`
 
 	public warn?: (...args: any[]) => void
 
-	public getRelatedKeys(key: AType): Set<BType> | undefined
-	public getRelatedKeys(key: BType): Set<AType> | undefined
-	public getRelatedKeys(key: AType | BType): Set<AType> | Set<BType> | undefined
-	public getRelatedKeys(
-		key: AType | BType,
-	): Set<AType> | Set<BType> | undefined {
+	public getRelatedKeys(key: A): Set<B> | undefined
+	public getRelatedKeys(key: B): Set<A> | undefined
+	public getRelatedKeys(key: A | B): Set<A> | Set<B> | undefined
+	public getRelatedKeys(key: A | B): Set<A> | Set<B> | undefined {
 		return this.relations.get(key)
 	}
-	protected addRelation(a: AType, b: BType): void {
-		let aRelations = this.relations.get(a) as Set<BType> | undefined
-		let bRelations = this.relations.get(b) as Set<AType> | undefined
+	protected addRelation(a: A, b: B): void {
+		let aRelations = this.relations.get(a) as Set<B> | undefined
+		let bRelations = this.relations.get(b) as Set<A> | undefined
 		if (aRelations) {
 			aRelations.add(b)
 		} else {
@@ -120,14 +121,14 @@ export class Junction<
 			this.relations.set(b, bRelations)
 		}
 	}
-	protected deleteRelation(a: AType, b: BType): void {
-		const aRelations = this.relations.get(a) as Set<BType> | undefined
+	protected deleteRelation(a: A, b: B): void {
+		const aRelations = this.relations.get(a) as Set<B> | undefined
 		if (aRelations) {
 			aRelations.delete(b)
 			if (aRelations.size === 0) {
 				this.relations.delete(a)
 			}
-			const bRelations = this.relations.get(b) as Set<AType> | undefined
+			const bRelations = this.relations.get(b) as Set<A> | undefined
 			if (bRelations) {
 				bRelations.delete(a)
 				if (bRelations.size === 0) {
@@ -137,31 +138,28 @@ export class Junction<
 		}
 	}
 
-	protected replaceRelationsUnsafely(a: AType, bs: BType[]): void
-	protected replaceRelationsUnsafely(b: BType, as: AType[]): void
-	protected replaceRelationsUnsafely(
-		x: AType | BType,
-		ys: AType[] | BType[],
-	): void {
-		this.relations.set(x as AType, new Set(ys as BType[]))
+	protected replaceRelationsUnsafely(a: A, bs: B[]): void
+	protected replaceRelationsUnsafely(b: B, as: A[]): void
+	protected replaceRelationsUnsafely(x: A | B, ys: A[] | B[]): void {
+		this.relations.set(x as A, new Set(ys as B[]))
 		for (const y of ys) {
-			const yRelations = new Set<AType>().add(x as AType)
+			const yRelations = new Set<A>().add(x as A)
 			this.relations.set(y, yRelations)
 		}
 	}
-	protected replaceRelationsSafely(a: AType, bs: BType[]): void
-	protected replaceRelationsSafely(b: BType, as: AType[]): void
+	protected replaceRelationsSafely(a: A, bs: B[]): void
+	protected replaceRelationsSafely(b: B, as: A[]): void
 	protected replaceRelationsSafely<
-		XType extends AType | BType,
-		YType extends XType extends AType ? BType : AType,
+		XType extends A | B,
+		YType extends XType extends A ? B : A,
 	>(x: XType, ys: YType[]): void {
 		const xRelationsPrev = this.relations.get(x)
-		let a: AType | undefined = this.isAType?.(x) ? x : undefined
-		let b: BType | undefined = a === undefined ? (x as BType) : undefined
+		let a: A | undefined = this.isAType?.(x) ? x : undefined
+		let b: B | undefined = a === undefined ? (x as B) : undefined
 		if (xRelationsPrev) {
 			for (const y of xRelationsPrev) {
-				a ??= y as AType
-				b ??= y as BType
+				a ??= y as A
+				b ??= y as B
 				const yRelations = this.relations.get(y) as Set<XType> | undefined
 				if (yRelations) {
 					if (yRelations.size === 1) {
@@ -196,26 +194,34 @@ export class Junction<
 	}
 
 	public constructor(
-		data: JunctionSchema<ASide, BSide> &
-			Partial<JunctionEntries<NoInfer<AType>, NoInfer<BType>, Content>>,
-		config?: JunctionAdvancedConfiguration<AType, BType, Content>,
+		data: JunctionSchema<AName, BName> &
+			Partial<JunctionEntries<NoInfer<A>, NoInfer<B>, Content>>,
+		config?: JunctionAdvancedConfiguration<AName, A, BName, B, Content>,
 	) {
 		this.a = data.between[0]
 		this.b = data.between[1]
 
 		this.cardinality = data.cardinality
-		if (!config?.externalStore) {
-			this.relations = new Map(
-				data.relations?.map(([x, ys]) => [x, new Set(ys as AType[])]),
-			)
-			this.contents = new Map(data.contents)
-		}
+
 		this.isAType = config?.isAType ?? null
 		this.isBType = config?.isBType ?? null
 		this.isContent = config?.isContent ?? null
 		if (config?.makeContentKey) {
 			this.makeContentKey = config.makeContentKey
 		}
+		if (!config?.externalStore) {
+			const source = config?.source
+			if (source === undefined) {
+				this.relations = new Map(
+					data.relations?.map(([x, ys]) => [x, new Set(ys as A[])]),
+				)
+				this.contents = new Map(data.contents)
+			}
+			if (source) {
+				this.relations = new RelationsOverlay(source.relations)
+				this.contents = new MapOverlay(source.contents)
+			}
+		}
 		if (config?.externalStore) {
 			const externalStore = config.externalStore
 			this.has = (a, b) => externalStore.has(a, b)
@@ -248,10 +254,10 @@ export class Junction<
 			}
 			for (const [x, ys] of data.relations ?? []) {
 				let a = this.isAType?.(x) ? x : undefined
-				let b = a === undefined ? (x as BType) : undefined
+				let b = a === undefined ? (x as B) : undefined
 				for (const y of ys) {
-					a ??= y as AType
-					b ??= y as BType
+					a ??= y as A
+					b ??= y as B
 					this.addRelation(a, b)
 				}
 			}
@@ -263,54 +269,41 @@ export class Junction<
 			this.warn = config.warn
 		}
 	}
-	public toJSON(): JunctionJSON<ASide, AType, BSide, BType, Content> {
+	public toJSON(): JunctionJSON<AName, A, BName, B, Content> {
 		return {
 			between: [this.a, this.b],
 			cardinality: this.cardinality,
 			relations: [...this.relations.entries()].map(
-				([a, b]) => [a, [...b]] as [AType, BType[]],
+				([a, b]) => [a, [...b]] as [A, B[]],
 			),
 			contents: [...this.contents.entries()],
 		}
 	}
 
 	public set(
-		a: AType,
-		...rest: Content extends null ? [b: BType] : [b: BType, content: Content]
+		a: A,
+		...rest: Content extends null ? [b: B] : [b: B, content: Content]
 	): this
 	public set(
-		relation: { [Key in ASide]: AType } & { [Key in BSide]: BType },
+		relation: { [Key in AName]: A } & { [Key in BName]: B },
 		...rest: Content extends null ? [] | [void?: undefined] : [content: Content]
 	): this
 	public set(
-		// a: AType | ({ [Key in ASide]: AType } & { [Key in BSide]: BType }),
-		// ...rest: Content extends null
-		// 	? [] | [b?: BType | undefined]
-		// 	: [b: BType, content: Content] | [content: Content]
 		...params:
 			| [
-					a: AType,
-					...rest: Content extends null
-						? [b: BType]
-						: [b: BType, content: Content],
-			  ]
-			| [
-					relation: { [Key in ASide]: AType } & { [Key in BSide]: BType },
+					relation: { [Key in AName]: A } & { [Key in BName]: B },
 					...rest: Content extends null
 						? [] | [void?: undefined]
 						: [content: Content],
 			  ]
-		// | [{ [Key in ASide]: AType } & { [Key in BSide]: BType }, content: Content]
-		// | [{ [Key in ASide]: AType } & { [Key in BSide]: BType }]
-		// | [a: AType, b: BType, content: Content]
-		// | [a: AType, b: BType]
+			| [a: A, ...rest: Content extends null ? [b: B] : [b: B, content: Content]]
 	): this {
-		let a: AType
-		let b: BType
+		let a: A
+		let b: B
 		let content: Content | undefined
 		switch (params.length) {
 			case 1: {
-				const relation = params[0] as Record<ASide, AType> & Record<BSide, BType>
+				const relation = params[0] as Record<AName, A> & Record<BName, B>
 				a = relation[this.a]
 				b = relation[this.b]
 				content = undefined
@@ -319,7 +312,7 @@ export class Junction<
 			case 2: {
 				const zeroth = params[0]
 				if (typeof zeroth === `string`) {
-					;[a, b] = params as unknown as [AType, BType]
+					;[a, b] = params as unknown as [A, B]
 				} else {
 					a = zeroth[this.a]
 					b = zeroth[this.b]
@@ -328,8 +321,8 @@ export class Junction<
 				break
 			}
 			default: {
-				a = params[0] as AType
-				b = params[1] as BType
+				a = params[0] as A
+				b = params[1] as B
 				content = params[2] as Content
 				break
 			}
@@ -356,47 +349,45 @@ export class Junction<
 		return this
 	}
 
-	public delete(a: AType, b?: BType): this
-	public delete(b: BType, a?: AType): this
+	public delete(a: A, b?: B): this
+	public delete(b: B, a?: A): this
 	public delete(
 		relation:
-			| { [Key in ASide]: AType }
-			| { [Key in BSide]: BType }
-			| ({ [Key in ASide]: AType } & { [Key in BSide]: BType }),
+			| { [Key in AName]: A }
+			| { [Key in BName]: B }
+			| ({ [Key in AName]: A } & { [Key in BName]: B }),
 		b?: undefined,
 	): this
 	public delete(
 		x:
-			| AType
-			| BType
-			| Record<ASide | BSide, string>
-			| Record<ASide, string>
-			| Record<BSide, string>,
-		b?: AType | BType,
+			| A
+			| B
+			| Record<AName | BName, string>
+			| Record<AName, string>
+			| Record<BName, string>,
+		b?: A | B,
 	): this {
 		// @ts-expect-error we deduce that this.b may index x
-		b = typeof b === `string` ? (b as BType) : (x[this.b] as BType | undefined)
+		b = typeof b === `string` ? (b as B) : (x[this.b] as B | undefined)
 		const a =
 			// @ts-expect-error we deduce that this.a may index x
-			typeof x === `string` ? (x as AType) : (x[this.a] as AType | undefined)
+			typeof x === `string` ? (x as A) : (x[this.a] as A | undefined)
 
 		if (a === undefined && typeof b === `string`) {
-			const bRelations = this.getRelatedKeys(b) as Set<AType>
+			const bRelations = this.getRelatedKeys(b) as Set<A>
 			if (bRelations) {
 				for (const bRelation of bRelations) {
 					this.delete(bRelation, b)
 				}
 			}
-		}
-		if (typeof a === `string` && b === undefined) {
+		} else if (typeof a === `string` && b === undefined) {
 			const aRelations = this.getRelatedKeys(a)
 			if (aRelations) {
 				for (const aRelation of aRelations) {
 					this.delete(a, aRelation)
 				}
 			}
-		}
-		if (typeof a === `string` && typeof b === `string`) {
+		} else if (typeof a === `string` && typeof b === `string`) {
 			this.deleteRelation(a, b)
 			const contentKey = this.makeContentKey(a, b)
 			this.deleteContent(contentKey)
@@ -404,9 +395,9 @@ export class Junction<
 		return this
 	}
 
-	public getRelatedKey(key: AType): BType | undefined
-	public getRelatedKey(key: BType): AType | undefined
-	public getRelatedKey(key: AType | BType): AType | BType | undefined {
+	public getRelatedKey(key: A): B | undefined
+	public getRelatedKey(key: B): A | undefined
+	public getRelatedKey(key: A | B): A | B | undefined {
 		const relations = this.getRelatedKeys(key)
 		if (relations) {
 			if (relations.size > 1) {
@@ -418,7 +409,7 @@ export class Junction<
 						.join(`, `)}). Only one related key was expected.`,
 				)
 			}
-			let singleRelation: AType | BType | undefined
+			let singleRelation: A | B | undefined
 			for (const relation of relations) {
 				singleRelation = relation
 				break
@@ -428,18 +419,18 @@ export class Junction<
 	}
 
 	public replaceRelations(
-		a: AType,
-		relations: Content extends null ? BType[] : Record<BType, Content>,
+		a: A,
+		relations: Content extends null ? B[] : Record<B, Content>,
 		config?: { reckless: boolean },
 	): this
 	public replaceRelations(
-		b: BType,
-		relations: Content extends null ? AType[] : Record<AType, Content>,
+		b: B,
+		relations: Content extends null ? A[] : Record<A, Content>,
 		config?: { reckless: boolean },
 	): this
 	public replaceRelations<
-		XType extends AType | BType,
-		YType extends XType extends AType ? BType : AType,
+		XType extends A | B,
+		YType extends XType extends A ? B : A,
 	>(
 		x: XType,
 		relations: Content extends null ? YType[] : Record<YType, Content>,
@@ -462,18 +453,18 @@ export class Junction<
 		return this
 	}
 
-	public getContent(a: AType, b: BType): Content | undefined {
+	public getContent(a: A, b: B): Content | undefined {
 		const contentKey = this.makeContentKey(a, b)
 		return this.getContentInternal(contentKey)
 	}
 
-	public getRelationEntries(input: Record<ASide, AType>): [BType, Content][]
-	public getRelationEntries(input: Record<BSide, BType>): [AType, Content][]
+	public getRelationEntries(input: Record<AName, A>): [B, Content][]
+	public getRelationEntries(input: Record<BName, B>): [A, Content][]
 	public getRelationEntries(
-		input: Record<ASide, AType> | Record<BSide, BType>,
-	): [AType | BType, Content][] {
-		const a: AType | undefined = (input as any)[this.a]
-		const b: BType | undefined = (input as any)[this.b]
+		input: Record<AName, A> | Record<BName, B>,
+	): [A | B, Content][] {
+		const a: A | undefined = (input as any)[this.a]
+		const b: B | undefined = (input as any)[this.b]
 		if (a !== undefined && b === undefined) {
 			const aRelations = this.getRelatedKeys(a)
 			if (aRelations) {
@@ -493,13 +484,66 @@ export class Junction<
 		return []
 	}
 
-	public has(a: AType, b?: BType): boolean
-	public has(b: BType, a?: AType): boolean
-	public has(a: AType | BType, b?: AType | BType): boolean {
+	public has(a: A, b?: B): boolean
+	public has(b: B, a?: A): boolean
+	public has(a: A | B, b?: A | B): boolean {
 		if (b) {
 			const setA = this.getRelatedKeys(a)
 			return setA?.has(b as any) ?? false
 		}
 		return this.relations.has(a)
 	}
+	public overlay(): JunctionOverlay<AName, A, BName, B, Content> {
+		const config: JunctionAdvancedConfiguration<AName, A, BName, B, Content> = {
+			source: this,
+			makeContentKey: this.makeContentKey,
+		}
+		if (this.isAType) config.isAType = this.isAType
+		if (this.isBType) config.isBType = this.isBType
+		if (this.isContent) config.isContent = this.isContent
+		if (this.warn) config.warn = this.warn
+
+		return new Junction(
+			{
+				between: [this.a, this.b],
+				cardinality: this.cardinality,
+			},
+			config,
+		) as JunctionOverlay<AName, A, BName, B, Content>
+	}
+	public incorporate(
+		overlay: JunctionOverlay<AName, A, BName, B, Content>,
+	): void {
+		const { relations, contents } = overlay
+		for (const [key, value] of relations) {
+			if (value instanceof SetOverlay) {
+				const { source } = value
+				for (const keyAdded of value.iterateOwn()) {
+					source.add(keyAdded)
+				}
+			} else {
+				this.relations.set(key, value)
+			}
+		}
+		for (const key of relations.deleted) {
+			this.relations.delete(key)
+		}
+		for (const [key, value] of contents) {
+			this.contents.set(key, value)
+		}
+		for (const key of contents.deleted) {
+			this.contents.delete(key)
+		}
+	}
+}
+
+export type JunctionOverlay<
+	AName extends string,
+	A extends string,
+	BName extends string,
+	B extends string,
+	Content extends Json.Object | null = null,
+> = Junction<AName, A, BName, B, Content> & {
+	relations: MapOverlay<A | B, Set<A> | Set<B>>
+	contents: MapOverlay<string, Content>
 }

package/src/internal/mutable/create-mutable-atom-family.ts

@@ -60,7 +60,7 @@ export function createMutableAtomFamily<
 
 		const token = createMutableAtom(target, individualOptions, family)
 
-		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
+		// subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 

package/src/internal/overlays/index.ts

@@ -0,0 +1,3 @@
+export * from "./map-overlay"
+export * from "./relations-overlay"
+export * from "./set-overlay"

package/src/internal/overlays/map-overlay.ts

@@ -0,0 +1,86 @@
+export class MapOverlay<K, V> extends Map<K, V> {
+	public deleted: Set<K> = new Set()
+	public changed: Set<K> = new Set()
+	protected readonly source: Map<K, V>
+
+	public constructor(source: Map<K, V>) {
+		super()
+		this.source = source
+	}
+
+	public get(key: K): V | undefined {
+		const has = super.has(key)
+		if (has) {
+			return super.get(key)
+		}
+		if (!this.deleted.has(key) && this.source.has(key)) {
+			const value = this.source.get(key)
+			return value
+		}
+		return undefined
+	}
+
+	public set(key: K, value: V): this {
+		this.deleted.delete(key)
+		if (this.source.has(key)) {
+			this.changed.add(key)
+		}
+		return super.set(key, value)
+	}
+
+	public hasOwn(key: K): boolean {
+		return super.has(key)
+	}
+
+	public has(key: K): boolean {
+		return !this.deleted.has(key) && (super.has(key) || this.source.has(key))
+	}
+
+	public delete(key: K): boolean {
+		if (this.source.has(key)) {
+			this.deleted.add(key)
+			this.changed.delete(key)
+		}
+		return super.delete(key)
+	}
+
+	public clear(): void {
+		this.deleted = new Set(this.source.keys())
+		this.changed.clear()
+		super.clear()
+	}
+
+	public *[Symbol.iterator](): MapIterator<[K, V]> {
+		yield* super[Symbol.iterator]()
+		for (const [key, value] of this.source) {
+			if (!this.deleted.has(key) && !this.changed.has(key)) {
+				yield [key, value]
+			}
+		}
+	}
+	public *entries(): MapIterator<[K, V]> {
+		yield* this[Symbol.iterator]()
+	}
+	public *keys(): MapIterator<K> {
+		yield* super.keys()
+		for (const key of this.source.keys()) {
+			if (!this.deleted.has(key) && !this.changed.has(key)) {
+				yield key
+			}
+		}
+	}
+	public *values(): MapIterator<V> {
+		for (const [, value] of this[Symbol.iterator]()) {
+			yield value
+		}
+	}
+	public forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void): void {
+		for (const [key, value] of this[Symbol.iterator]()) {
+			callbackfn(value, key, this)
+		}
+	}
+
+	public get size(): number {
+		return super.size + this.source.size - this.changed.size - this.deleted.size
+	}
+}

package/src/internal/{lazy-map.ts → overlays/relations-overlay.ts}

@@ -1,4 +1,6 @@
-export class LazyMap<K, V> extends Map<K, V> {
+import { SetOverlay } from "./set-overlay"
+
+export class RelationsOverlay<K, V extends Set<any>> extends Map<K, V> {
 	public deleted: Set<K> = new Set()
 	protected readonly source: Map<K, V>
 
@@ -14,7 +16,9 @@ export class LazyMap<K, V> extends Map<K, V> {
 		}
 		if (!this.deleted.has(key) && this.source.has(key)) {
 			const value = this.source.get(key)
-			return value
+			const valueOverlay = new SetOverlay(value as V) as unknown as V
+			super.set(key, valueOverlay)
+			return valueOverlay
 		}
 		return undefined
 	}
@@ -24,10 +28,6 @@ export class LazyMap<K, V> extends Map<K, V> {
 		return super.set(key, value)
 	}
 
-	public hasOwn(key: K): boolean {
-		return super.has(key)
-	}
-
 	public has(key: K): boolean {
 		return !this.deleted.has(key) && (super.has(key) || this.source.has(key))
 	}