Keep reference equality roundtripping maps and arrays through XPath

src/expressions/adaptJavaScriptValueToXPathValue.ts

@@ -1,7 +1,7 @@
 import { NodePointer } from '../domClone/Pointer';
 import DomFacade from '../domFacade/DomFacade';
 import { UntypedExternalValue, ValidValue } from '../types/createTypedValueFactory';
-import ArrayValue from './dataTypes/ArrayValue';
+import ArrayValue, { ABSENT_JSON_ARRAY } from './dataTypes/ArrayValue';
 import { getValidatorForType } from './dataTypes/builtins/dataTypeValidatorByType';
 import createAtomicValue, { falseBoolean, trueBoolean } from './dataTypes/createAtomicValue';
 import createPointerValue from './dataTypes/createPointerValue';
@@ -56,7 +56,8 @@ export function adaptSingleJavaScriptValue(value: ValidValue, domFacade: DomFaca
 								: sequenceFactory.singleton(adaptedValue);
 
 						return createDoublyIterableSequence(adaptedSequence);
-					})
+					}),
+					value
 				);
 			}
 			// Make it a map
@@ -75,7 +76,8 @@ export function adaptSingleJavaScriptValue(value: ValidValue, domFacade: DomFaca
 							key: createAtomicValue(key, ValueType.XSSTRING),
 							value: createDoublyIterableSequence(adaptedSequence),
 						};
-					})
+					}),
+				mapValue as any
 			);
 	}
 	// This code will be reached if the passed value is not actually a ValidValue. This can happen

src/expressions/arrays/CurlyArrayConstructor.ts

@@ -1,4 +1,4 @@
-import ArrayValue from '../dataTypes/ArrayValue';
+import ArrayValue, { ABSENT_JSON_ARRAY } from '../dataTypes/ArrayValue';
 import sequenceFactory from '../dataTypes/sequenceFactory';
 import { SequenceType } from '../dataTypes/Value';
 import DynamicContext from '../DynamicContext';
@@ -29,7 +29,7 @@ class CurlyArrayConstructor extends Expression {
 
 	public evaluate(dynamicContext: DynamicContext, executionParameters: ExecutionParameters) {
 		if (this._members.length === 0) {
-			return sequenceFactory.singleton(new ArrayValue([]));
+			return sequenceFactory.singleton(new ArrayValue([], ABSENT_JSON_ARRAY));
 		}
 		return this._members[0]
 			.evaluateMaybeStatically(dynamicContext, executionParameters)
@@ -38,7 +38,8 @@ class CurlyArrayConstructor extends Expression {
 					new ArrayValue(
 						allValues.map((item) =>
 							createDoublyIterableSequence(sequenceFactory.singleton(item))
-						)
+						),
+						ABSENT_JSON_ARRAY
 					)
 				)
 			);

src/expressions/arrays/SquareArrayConstructor.ts

@@ -1,4 +1,4 @@
-import ArrayValue from '../dataTypes/ArrayValue';
+import ArrayValue, { ABSENT_JSON_ARRAY } from '../dataTypes/ArrayValue';
 import sequenceFactory from '../dataTypes/sequenceFactory';
 import { SequenceType } from '../dataTypes/Value';
 import DynamicContext from '../DynamicContext';
@@ -34,7 +34,8 @@ class SquareArrayConstructor extends Expression {
 					createDoublyIterableSequence(
 						entry.evaluateMaybeStatically(dynamicContext, executionParameters)
 					)
-				)
+				),
+				ABSENT_JSON_ARRAY
 			)
 		);
 	}

src/expressions/dataTypes/ArrayValue.ts

@@ -2,12 +2,16 @@ import arrayGet from '../functions/builtInFunctions_arrays_get';
 import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
 import FunctionValue from './FunctionValue';
 import ISequence from './ISequence';
+import { JsonArray } from './MapValue';
 import sequenceFactory from './sequenceFactory';
 import { SequenceMultiplicity, ValueType } from './Value';
 
+export const ABSENT_JSON_ARRAY = Symbol('ABSENT_JSON_ARRAY');
+
 class ArrayValue extends FunctionValue {
 	public members: (() => ISequence)[];
-	constructor(members: (() => ISequence)[]) {
+	public jsonArray: JsonArray | typeof ABSENT_JSON_ARRAY;
+	constructor(members: (() => ISequence)[], jsonArray: JsonArray | typeof ABSENT_JSON_ARRAY) {
 		super({
 			value: (dynamicContext, executionParameters, staticContext, key) =>
 				arrayGet(
@@ -26,6 +30,7 @@ class ArrayValue extends FunctionValue {
 		});
 		this.type = ValueType.ARRAY;
 		this.members = members;
+		this.jsonArray = jsonArray;
 	}
 }
 

src/expressions/dataTypes/MapValue.ts

@@ -5,9 +5,19 @@ import ISequence from './ISequence';
 import sequenceFactory from './sequenceFactory';
 import Value, { SequenceMultiplicity, ValueType } from './Value';
 
+export type JsonObject = {
+	[key: string]: JsonObject | string | number | boolean | JsonArray;
+};
+export type JsonArray = (JsonObject | JsonArray | string | number | boolean)[];
+export const AbsentJsonObject = Symbol('absentJsonObject');
+
 class MapValue extends FunctionValue<ISequence> {
 	public keyValuePairs: { key: Value; value: () => ISequence }[];
-	constructor(keyValuePairs: { key: Value; value: () => ISequence }[]) {
+	public jsonObject: JsonObject | typeof AbsentJsonObject;
+	constructor(
+		keyValuePairs: { key: Value; value: () => ISequence }[],
+		jsonObject: JsonObject | typeof AbsentJsonObject
+	) {
 		super({
 			// argumentTypes: [{ type: 'item()', isRestArgument: false }],
 			argumentTypes: [{ type: ValueType.ITEM, mult: SequenceMultiplicity.EXACTLY_ONE }],
@@ -26,6 +36,7 @@ class MapValue extends FunctionValue<ISequence> {
 		});
 		this.type = ValueType.MAP;
 		this.keyValuePairs = keyValuePairs;
+		this.jsonObject = jsonObject;
 	}
 }
 export default MapValue;

src/expressions/functions/builtInFunctions_arrays.ts

@@ -1,4 +1,4 @@
-import ArrayValue from '../dataTypes/ArrayValue';
+import ArrayValue, { ABSENT_JSON_ARRAY } from '../dataTypes/ArrayValue';
 import createAtomicValue from '../dataTypes/createAtomicValue';
 import FunctionValue, { FunctionSignature } from '../dataTypes/FunctionValue';
 import ISequence from '../dataTypes/ISequence';
@@ -48,7 +48,7 @@ const arrayPut: FunctionDefinitionType = (
 		}
 		const newMembers = (array as ArrayValue).members.concat();
 		newMembers.splice(positionValue - 1, 1, createDoublyIterableSequence(itemSequence));
-		return sequenceFactory.singleton(new ArrayValue(newMembers));
+		return sequenceFactory.singleton(new ArrayValue(newMembers, ABSENT_JSON_ARRAY));
 	});
 };
 
@@ -63,7 +63,7 @@ const arrayAppend: FunctionDefinitionType = (
 		const newMembers = (array as ArrayValue).members.concat([
 			createDoublyIterableSequence(itemSequence),
 		]);
-		return sequenceFactory.singleton(new ArrayValue(newMembers));
+		return sequenceFactory.singleton(new ArrayValue(newMembers, ABSENT_JSON_ARRAY));
 	});
 };
 
@@ -97,7 +97,7 @@ const arraySubarray: FunctionDefinitionType = (
 				startValue - 1,
 				lengthValue + startValue - 1
 			);
-			return sequenceFactory.singleton(new ArrayValue(newMembers));
+			return sequenceFactory.singleton(new ArrayValue(newMembers, ABSENT_JSON_ARRAY));
 		}
 	);
 };
@@ -126,7 +126,7 @@ const arrayRemove: FunctionDefinitionType = (
 				newMembers.splice(position - 1, 1);
 			}
 
-			return sequenceFactory.singleton(new ArrayValue(newMembers));
+			return sequenceFactory.singleton(new ArrayValue(newMembers, ABSENT_JSON_ARRAY));
 		})
 	);
 };
@@ -148,7 +148,7 @@ const arrayInsertBefore: FunctionDefinitionType = (
 
 		const newMembers = (array as ArrayValue).members.concat();
 		newMembers.splice(positionValue - 1, 0, createDoublyIterableSequence(itemSequence));
-		return sequenceFactory.singleton(new ArrayValue(newMembers));
+		return sequenceFactory.singleton(new ArrayValue(newMembers, ABSENT_JSON_ARRAY));
 	});
 };
 
@@ -159,7 +159,9 @@ const arrayReverse: FunctionDefinitionType = (
 	arraySequence
 ) => {
 	return zipSingleton([arraySequence], ([array]) =>
-		sequenceFactory.singleton(new ArrayValue((array as ArrayValue).members.concat().reverse()))
+		sequenceFactory.singleton(
+			new ArrayValue((array as ArrayValue).members.concat().reverse(), ABSENT_JSON_ARRAY)
+		)
 	);
 };
 
@@ -174,7 +176,7 @@ const arrayJoin: FunctionDefinitionType = (
 			(joinedMembers, array) => joinedMembers.concat((array as ArrayValue).members),
 			[]
 		);
-		return sequenceFactory.singleton(new ArrayValue(newMembers));
+		return sequenceFactory.singleton(new ArrayValue(newMembers, ABSENT_JSON_ARRAY));
 	});
 };
 
@@ -206,7 +208,7 @@ const arrayForEach: FunctionDefinitionType = (
 				)
 			);
 		});
-		return sequenceFactory.singleton(new ArrayValue(newMembers));
+		return sequenceFactory.singleton(new ArrayValue(newMembers, ABSENT_JSON_ARRAY));
 	});
 };
 
@@ -250,7 +252,7 @@ const arrayFilter: FunctionDefinitionType = (
 					(_, i) => effectiveBooleanValues[i]
 				);
 				done = true;
-				return ready(new ArrayValue(newMembers));
+				return ready(new ArrayValue(newMembers, ABSENT_JSON_ARRAY));
 			},
 		});
 	});
@@ -371,7 +373,7 @@ const arrayForEachPair: FunctionDefinitionType = (
 				);
 			}
 
-			return sequenceFactory.singleton(new ArrayValue(newMembers));
+			return sequenceFactory.singleton(new ArrayValue(newMembers, ABSENT_JSON_ARRAY));
 		}
 	);
 };
@@ -444,7 +446,10 @@ const arraySortCallback = (
 	});
 
 	return sequenceFactory.singleton(
-		new ArrayValue(allValues.map((item) => () => sequenceFactory.create(item)))
+		new ArrayValue(
+			allValues.map((item) => () => sequenceFactory.create(item)),
+			ABSENT_JSON_ARRAY
+		)
 	);
 };
 const arraySort: FunctionDefinitionType = (

src/expressions/functions/builtInFunctions_json.ts

@@ -1,7 +1,7 @@
-import ArrayValue from '../dataTypes/ArrayValue';
+import ArrayValue, { ABSENT_JSON_ARRAY } from '../dataTypes/ArrayValue';
 import createAtomicValue from '../dataTypes/createAtomicValue';
 import ISequence from '../dataTypes/ISequence';
-import MapValue from '../dataTypes/MapValue';
+import MapValue, { AbsentJsonObject } from '../dataTypes/MapValue';
 import sequenceFactory from '../dataTypes/sequenceFactory';
 import { SequenceMultiplicity, ValueType } from '../dataTypes/Value';
 import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
@@ -15,7 +15,8 @@ function convert(obj: any): ISequence {
 			if (Array.isArray(obj)) {
 				return sequenceFactory.singleton(
 					new ArrayValue(
-						obj.map((subObject) => createDoublyIterableSequence(convert(subObject)))
+						obj.map((subObject) => createDoublyIterableSequence(convert(subObject))),
+						ABSENT_JSON_ARRAY
 					)
 				);
 			}
@@ -31,7 +32,8 @@ function convert(obj: any): ISequence {
 							key: createAtomicValue(key, ValueType.XSSTRING),
 							value: createDoublyIterableSequence(convert(objThingy[key])),
 						};
-					})
+					}),
+					AbsentJsonObject
 				)
 			);
 		case 'number':

src/expressions/functions/builtInFunctions_maps.ts

@@ -1,5 +1,5 @@
 import createAtomicValue from '../dataTypes/createAtomicValue';
-import MapValue from '../dataTypes/MapValue';
+import MapValue, { AbsentJsonObject } from '../dataTypes/MapValue';
 import sequenceFactory from '../dataTypes/sequenceFactory';
 import { SequenceMultiplicity, ValueType } from '../dataTypes/Value';
 import { BUILT_IN_NAMESPACE_URIS } from '../staticallyKnownNamespaces';
@@ -78,7 +78,8 @@ const mapMerge: FunctionDefinitionType = (
 						resultingKeyValuePairs.push(keyValuePair);
 					});
 					return resultingKeyValuePairs;
-				}, [])
+				}, []),
+				AbsentJsonObject
 			)
 		)
 	);
@@ -109,7 +110,7 @@ const mapPut: FunctionDefinitionType = (
 				value: createDoublyIterableSequence(newValueSequence),
 			});
 		}
-		return sequenceFactory.singleton(new MapValue(resultingKeyValuePairs));
+		return sequenceFactory.singleton(new MapValue(resultingKeyValuePairs, AbsentJsonObject));
 	});
 };
 
@@ -121,7 +122,11 @@ const mapEntry: FunctionDefinitionType = (
 	value
 ) => {
 	return keySequence.map(
-		(onlyKey) => new MapValue([{ key: onlyKey, value: createDoublyIterableSequence(value) }])
+		(onlyKey) =>
+			new MapValue(
+				[{ key: onlyKey, value: createDoublyIterableSequence(value) }],
+				AbsentJsonObject
+			)
 	);
 };
 
@@ -182,7 +187,9 @@ const mapRemove: FunctionDefinitionType = (
 					resultingKeyValuePairs.splice(indexOfExistingPair, 1);
 				}
 			});
-			return sequenceFactory.singleton(new MapValue(resultingKeyValuePairs));
+			return sequenceFactory.singleton(
+				new MapValue(resultingKeyValuePairs, AbsentJsonObject)
+			);
 		});
 	});
 };
@@ -287,15 +294,18 @@ const declarations: BuiltinDeclarationType[] = [
 				staticContext,
 				maps,
 				sequenceFactory.singleton(
-					new MapValue([
-						{
-							key: createAtomicValue('duplicates', ValueType.XSSTRING),
-							value: () =>
-								sequenceFactory.singleton(
-									createAtomicValue('use-first', ValueType.XSSTRING)
-								),
-						},
-					])
+					new MapValue(
+						[
+							{
+								key: createAtomicValue('duplicates', ValueType.XSSTRING),
+								value: () =>
+									sequenceFactory.singleton(
+										createAtomicValue('use-first', ValueType.XSSTRING)
+									),
+							},
+						],
+						AbsentJsonObject
+					)
 				)
 			);
 		},