@qwik.dev/devtools 0.2.5 → 0.2.7

package/dist/ui/node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-decimal.qwik.mjs

@@ -1,8 +1,16 @@
-const decimalRegex = /\d/;
+//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-decimal.js
+var decimalRegex = /\d/;
+/**
+* Configurable ways to encode characters as decimal references.
+*
+* @param {number} code
+* @param {number} next
+* @param {boolean|undefined} omit
+* @returns {string}
+*/
 function toDecimal(code, next, omit) {
-  const value = "&#" + String(code);
-  return omit && next && !decimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
+	const value = "&#" + String(code);
+	return omit && next && !decimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
 }
-export {
-  toDecimal
-};
+//#endregion
+export { toDecimal };

package/dist/ui/node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-hexadecimal.qwik.mjs

@@ -1,8 +1,16 @@
-const hexadecimalRegex = /[\dA-Fa-f]/;
+//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-hexadecimal.js
+var hexadecimalRegex = /[\dA-Fa-f]/;
+/**
+* Configurable ways to encode characters as hexadecimal references.
+*
+* @param {number} code
+* @param {number} next
+* @param {boolean|undefined} omit
+* @returns {string}
+*/
 function toHexadecimal(code, next, omit) {
-  const value = "&#x" + code.toString(16).toUpperCase();
-  return omit && next && !hexadecimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
+	const value = "&#x" + code.toString(16).toUpperCase();
+	return omit && next && !hexadecimalRegex.test(String.fromCharCode(next)) ? value : value + ";";
 }
-export {
-  toHexadecimal
-};
+//#endregion
+export { toHexadecimal };

package/dist/ui/node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-named.qwik.mjs

@@ -1,27 +1,36 @@
 import { characterEntitiesLegacy } from "../../../../../character-entities-legacy@3.0.0/node_modules/character-entities-legacy/index.qwik.mjs";
 import { characterEntitiesHtml4 } from "../../../../../character-entities-html4@2.1.0/node_modules/character-entities-html4/index.qwik.mjs";
 import { dangerous } from "../constant/dangerous.qwik.mjs";
-const own = {}.hasOwnProperty;
-const characters = {};
-let key;
-for (key in characterEntitiesHtml4) {
-  if (own.call(characterEntitiesHtml4, key)) {
-    characters[characterEntitiesHtml4[key]] = key;
-  }
-}
-const notAlphanumericRegex = /[^\dA-Za-z]/;
+//#region ../../node_modules/.pnpm/stringify-entities@4.0.4/node_modules/stringify-entities/lib/util/to-named.js
+var own = {}.hasOwnProperty;
+/**
+* `characterEntitiesHtml4` but inverted.
+*
+* @type {Record<string, string>}
+*/
+var characters = {};
+/** @type {string} */
+var key;
+for (key in characterEntitiesHtml4) if (own.call(characterEntitiesHtml4, key)) characters[characterEntitiesHtml4[key]] = key;
+var notAlphanumericRegex = /[^\dA-Za-z]/;
+/**
+* Configurable ways to encode characters as named references.
+*
+* @param {number} code
+* @param {number} next
+* @param {boolean|undefined} omit
+* @param {boolean|undefined} attribute
+* @returns {string}
+*/
 function toNamed(code, next, omit, attribute) {
-  const character = String.fromCharCode(code);
-  if (own.call(characters, character)) {
-    const name = characters[character];
-    const value = "&" + name;
-    if (omit && characterEntitiesLegacy.includes(name) && !dangerous.includes(name) && (!attribute || next && next !== 61 && notAlphanumericRegex.test(String.fromCharCode(next)))) {
-      return value;
-    }
-    return value + ";";
-  }
-  return "";
+	const character = String.fromCharCode(code);
+	if (own.call(characters, character)) {
+		const name = characters[character];
+		const value = "&" + name;
+		if (omit && characterEntitiesLegacy.includes(name) && !dangerous.includes(name) && (!attribute || next && next !== 61 && notAlphanumericRegex.test(String.fromCharCode(next)))) return value;
+		return value + ";";
+	}
+	return "";
 }
-export {
-  toNamed
-};
+//#endregion
+export { toNamed };

package/dist/ui/node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/accessDeep.qwik.mjs

@@ -0,0 +1,96 @@
+import { includes } from "./util.qwik.mjs";
+import { isArray, isMap, isPlainObject, isSet } from "./is.qwik.mjs";
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/accessDeep.js
+var getNthKey = (value, n) => {
+	if (n > value.size) throw new Error("index out of bounds");
+	const keys = value.keys();
+	while (n > 0) {
+		keys.next();
+		n--;
+	}
+	return keys.next().value;
+};
+function validatePath(path) {
+	if (includes(path, "__proto__")) throw new Error("__proto__ is not allowed as a property");
+	if (includes(path, "prototype")) throw new Error("prototype is not allowed as a property");
+	if (includes(path, "constructor")) throw new Error("constructor is not allowed as a property");
+}
+var getDeep = (object, path) => {
+	validatePath(path);
+	for (let i = 0; i < path.length; i++) {
+		const key = path[i];
+		if (isSet(object)) object = getNthKey(object, +key);
+		else if (isMap(object)) {
+			const row = +key;
+			const type = +path[++i] === 0 ? "key" : "value";
+			const keyOfRow = getNthKey(object, row);
+			switch (type) {
+				case "key":
+					object = keyOfRow;
+					break;
+				case "value":
+					object = object.get(keyOfRow);
+					break;
+			}
+		} else object = object[key];
+	}
+	return object;
+};
+var setDeep = (object, path, mapper) => {
+	validatePath(path);
+	if (path.length === 0) return mapper(object);
+	let parent = object;
+	for (let i = 0; i < path.length - 1; i++) {
+		const key = path[i];
+		if (isArray(parent)) {
+			const index = +key;
+			parent = parent[index];
+		} else if (isPlainObject(parent)) parent = parent[key];
+		else if (isSet(parent)) {
+			const row = +key;
+			parent = getNthKey(parent, row);
+		} else if (isMap(parent)) {
+			if (i === path.length - 2) break;
+			const row = +key;
+			const type = +path[++i] === 0 ? "key" : "value";
+			const keyOfRow = getNthKey(parent, row);
+			switch (type) {
+				case "key":
+					parent = keyOfRow;
+					break;
+				case "value":
+					parent = parent.get(keyOfRow);
+					break;
+			}
+		}
+	}
+	const lastKey = path[path.length - 1];
+	if (isArray(parent)) parent[+lastKey] = mapper(parent[+lastKey]);
+	else if (isPlainObject(parent)) parent[lastKey] = mapper(parent[lastKey]);
+	if (isSet(parent)) {
+		const oldValue = getNthKey(parent, +lastKey);
+		const newValue = mapper(oldValue);
+		if (oldValue !== newValue) {
+			parent.delete(oldValue);
+			parent.add(newValue);
+		}
+	}
+	if (isMap(parent)) {
+		const row = +path[path.length - 2];
+		const keyToRow = getNthKey(parent, row);
+		switch (+lastKey === 0 ? "key" : "value") {
+			case "key": {
+				const newKey = mapper(keyToRow);
+				parent.set(newKey, parent.get(keyToRow));
+				if (newKey !== keyToRow) parent.delete(keyToRow);
+				break;
+			}
+			case "value":
+				parent.set(keyToRow, mapper(parent.get(keyToRow)));
+				break;
+		}
+	}
+	return object;
+};
+//#endregion
+export { getDeep, setDeep };

package/dist/ui/node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/class-registry.qwik.mjs

@@ -0,0 +1,19 @@
+import { Registry } from "./registry.qwik.mjs";
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/class-registry.js
+var ClassRegistry = class extends Registry {
+	constructor() {
+		super((c) => c.name);
+		this.classToAllowedProps = /* @__PURE__ */ new Map();
+	}
+	register(value, options) {
+		if (typeof options === "object") {
+			if (options.allowProps) this.classToAllowedProps.set(value, options.allowProps);
+			super.register(value, options.identifier);
+		} else super.register(value, options);
+	}
+	getAllowedProps(value) {
+		return this.classToAllowedProps.get(value);
+	}
+};
+//#endregion
+export { ClassRegistry };

package/dist/ui/node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/custom-transformer-registry.qwik.mjs

@@ -0,0 +1,18 @@
+import { find } from "./util.qwik.mjs";
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/custom-transformer-registry.js
+var CustomTransformerRegistry = class {
+	constructor() {
+		this.transfomers = {};
+	}
+	register(transformer) {
+		this.transfomers[transformer.name] = transformer;
+	}
+	findApplicable(v) {
+		return find(this.transfomers, (transformer) => transformer.isApplicable(v));
+	}
+	findByName(name) {
+		return this.transfomers[name];
+	}
+};
+//#endregion
+export { CustomTransformerRegistry };

package/dist/ui/node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/double-indexed-kv.qwik.mjs

@@ -0,0 +1,23 @@
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/double-indexed-kv.js
+var DoubleIndexedKV = class {
+	constructor() {
+		this.keyToValue = /* @__PURE__ */ new Map();
+		this.valueToKey = /* @__PURE__ */ new Map();
+	}
+	set(key, value) {
+		this.keyToValue.set(key, value);
+		this.valueToKey.set(value, key);
+	}
+	getByKey(key) {
+		return this.keyToValue.get(key);
+	}
+	getByValue(value) {
+		return this.valueToKey.get(value);
+	}
+	clear() {
+		this.keyToValue.clear();
+		this.valueToKey.clear();
+	}
+};
+//#endregion
+export { DoubleIndexedKV };

package/dist/ui/node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/index.qwik.mjs

@@ -0,0 +1,81 @@
+import { Registry } from "./registry.qwik.mjs";
+import { ClassRegistry } from "./class-registry.qwik.mjs";
+import { CustomTransformerRegistry } from "./custom-transformer-registry.qwik.mjs";
+import { applyReferentialEqualityAnnotations, applyValueAnnotations, generateReferentialEqualityAnnotations, walker } from "./plainer.qwik.mjs";
+import { copy } from "../../../../copy-anything@4.0.5/node_modules/copy-anything/dist/index.qwik.mjs";
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/index.js
+var SuperJSON = class {
+	/**
+	* @param dedupeReferentialEqualities  If true, SuperJSON will make sure only one instance of referentially equal objects are serialized and the rest are replaced with `null`.
+	*/
+	constructor({ dedupe = false } = {}) {
+		this.classRegistry = new ClassRegistry();
+		this.symbolRegistry = new Registry((s) => s.description ?? "");
+		this.customTransformerRegistry = new CustomTransformerRegistry();
+		this.allowedErrorProps = [];
+		this.dedupe = dedupe;
+	}
+	serialize(object) {
+		const identities = /* @__PURE__ */ new Map();
+		const output = walker(object, identities, this, this.dedupe);
+		const res = { json: output.transformedValue };
+		if (output.annotations) res.meta = {
+			...res.meta,
+			values: output.annotations
+		};
+		const equalityAnnotations = generateReferentialEqualityAnnotations(identities, this.dedupe);
+		if (equalityAnnotations) res.meta = {
+			...res.meta,
+			referentialEqualities: equalityAnnotations
+		};
+		if (res.meta) res.meta.v = 1;
+		return res;
+	}
+	deserialize(payload, options) {
+		const { json, meta } = payload;
+		let result = options?.inPlace ? json : copy(json);
+		if (meta?.values) result = applyValueAnnotations(result, meta.values, meta.v ?? 0, this);
+		if (meta?.referentialEqualities) result = applyReferentialEqualityAnnotations(result, meta.referentialEqualities, meta.v ?? 0);
+		return result;
+	}
+	stringify(object) {
+		return JSON.stringify(this.serialize(object));
+	}
+	parse(string) {
+		return this.deserialize(JSON.parse(string), { inPlace: true });
+	}
+	registerClass(v, options) {
+		this.classRegistry.register(v, options);
+	}
+	registerSymbol(v, identifier) {
+		this.symbolRegistry.register(v, identifier);
+	}
+	registerCustom(transformer, name) {
+		this.customTransformerRegistry.register({
+			name,
+			...transformer
+		});
+	}
+	allowErrorProps(...props) {
+		this.allowedErrorProps.push(...props);
+	}
+};
+SuperJSON.defaultInstance = new SuperJSON();
+SuperJSON.serialize = SuperJSON.defaultInstance.serialize.bind(SuperJSON.defaultInstance);
+SuperJSON.deserialize = SuperJSON.defaultInstance.deserialize.bind(SuperJSON.defaultInstance);
+SuperJSON.stringify = SuperJSON.defaultInstance.stringify.bind(SuperJSON.defaultInstance);
+SuperJSON.parse = SuperJSON.defaultInstance.parse.bind(SuperJSON.defaultInstance);
+SuperJSON.registerClass = SuperJSON.defaultInstance.registerClass.bind(SuperJSON.defaultInstance);
+SuperJSON.registerSymbol = SuperJSON.defaultInstance.registerSymbol.bind(SuperJSON.defaultInstance);
+SuperJSON.registerCustom = SuperJSON.defaultInstance.registerCustom.bind(SuperJSON.defaultInstance);
+SuperJSON.allowErrorProps = SuperJSON.defaultInstance.allowErrorProps.bind(SuperJSON.defaultInstance);
+SuperJSON.serialize;
+SuperJSON.deserialize;
+SuperJSON.stringify;
+SuperJSON.parse;
+SuperJSON.registerClass;
+SuperJSON.registerCustom;
+SuperJSON.registerSymbol;
+SuperJSON.allowErrorProps;
+//#endregion
+export { SuperJSON as default };

package/dist/ui/node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/is.qwik.mjs

@@ -0,0 +1,29 @@
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/is.js
+var getType = (payload) => Object.prototype.toString.call(payload).slice(8, -1);
+var isUndefined = (payload) => typeof payload === "undefined";
+var isNull = (payload) => payload === null;
+var isPlainObject = (payload) => {
+	if (typeof payload !== "object" || payload === null) return false;
+	if (payload === Object.prototype) return false;
+	if (Object.getPrototypeOf(payload) === null) return true;
+	return Object.getPrototypeOf(payload) === Object.prototype;
+};
+var isEmptyObject = (payload) => isPlainObject(payload) && Object.keys(payload).length === 0;
+var isArray = (payload) => Array.isArray(payload);
+var isString = (payload) => typeof payload === "string";
+var isNumber = (payload) => typeof payload === "number" && !isNaN(payload);
+var isBoolean = (payload) => typeof payload === "boolean";
+var isRegExp = (payload) => payload instanceof RegExp;
+var isMap = (payload) => payload instanceof Map;
+var isSet = (payload) => payload instanceof Set;
+var isSymbol = (payload) => getType(payload) === "Symbol";
+var isDate = (payload) => payload instanceof Date && !isNaN(payload.valueOf());
+var isError = (payload) => payload instanceof Error;
+var isNaNValue = (payload) => typeof payload === "number" && isNaN(payload);
+var isPrimitive = (payload) => isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
+var isBigint = (payload) => typeof payload === "bigint";
+var isInfinite = (payload) => payload === Infinity || payload === -Infinity;
+var isTypedArray = (payload) => ArrayBuffer.isView(payload) && !(payload instanceof DataView);
+var isURL = (payload) => payload instanceof URL;
+//#endregion
+export { isArray, isBigint, isDate, isEmptyObject, isError, isInfinite, isMap, isNaNValue, isPlainObject, isPrimitive, isRegExp, isSet, isSymbol, isTypedArray, isURL, isUndefined };

package/dist/ui/node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/pathstringifier.qwik.mjs

@@ -0,0 +1,34 @@
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/pathstringifier.js
+var escapeKey = (key) => key.replace(/\\/g, "\\\\").replace(/\./g, "\\.");
+var stringifyPath = (path) => path.map(String).map(escapeKey).join(".");
+var parsePath = (string, legacyPaths) => {
+	const result = [];
+	let segment = "";
+	for (let i = 0; i < string.length; i++) {
+		let char = string.charAt(i);
+		if (!legacyPaths && char === "\\") {
+			const escaped = string.charAt(i + 1);
+			if (escaped === "\\") {
+				segment += "\\";
+				i++;
+				continue;
+			} else if (escaped !== ".") throw Error("invalid path");
+		}
+		if (char === "\\" && string.charAt(i + 1) === ".") {
+			segment += ".";
+			i++;
+			continue;
+		}
+		if (char === ".") {
+			result.push(segment);
+			segment = "";
+			continue;
+		}
+		segment += char;
+	}
+	const lastSegment = segment;
+	result.push(lastSegment);
+	return result;
+};
+//#endregion
+export { escapeKey, parsePath, stringifyPath };

package/dist/ui/node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/plainer.qwik.mjs

@@ -0,0 +1,105 @@
+import { forEach, includes } from "./util.qwik.mjs";
+import { isArray, isEmptyObject, isError, isMap, isPlainObject, isPrimitive, isSet } from "./is.qwik.mjs";
+import { escapeKey, parsePath, stringifyPath } from "./pathstringifier.qwik.mjs";
+import { isInstanceOfRegisteredClass, transformValue, untransformValue } from "./transformer.qwik.mjs";
+import { getDeep, setDeep } from "./accessDeep.qwik.mjs";
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/plainer.js
+var enableLegacyPaths = (version) => version < 1;
+function traverse(tree, walker, version, origin = []) {
+	if (!tree) return;
+	const legacyPaths = enableLegacyPaths(version);
+	if (!isArray(tree)) {
+		forEach(tree, (subtree, key) => traverse(subtree, walker, version, [...origin, ...parsePath(key, legacyPaths)]));
+		return;
+	}
+	const [nodeValue, children] = tree;
+	if (children) forEach(children, (child, key) => {
+		traverse(child, walker, version, [...origin, ...parsePath(key, legacyPaths)]);
+	});
+	walker(nodeValue, origin);
+}
+function applyValueAnnotations(plain, annotations, version, superJson) {
+	traverse(annotations, (type, path) => {
+		plain = setDeep(plain, path, (v) => untransformValue(v, type, superJson));
+	}, version);
+	return plain;
+}
+function applyReferentialEqualityAnnotations(plain, annotations, version) {
+	const legacyPaths = enableLegacyPaths(version);
+	function apply(identicalPaths, path) {
+		const object = getDeep(plain, parsePath(path, legacyPaths));
+		identicalPaths.map((path) => parsePath(path, legacyPaths)).forEach((identicalObjectPath) => {
+			plain = setDeep(plain, identicalObjectPath, () => object);
+		});
+	}
+	if (isArray(annotations)) {
+		const [root, other] = annotations;
+		root.forEach((identicalPath) => {
+			plain = setDeep(plain, parsePath(identicalPath, legacyPaths), () => plain);
+		});
+		if (other) forEach(other, apply);
+	} else forEach(annotations, apply);
+	return plain;
+}
+var isDeep = (object, superJson) => isPlainObject(object) || isArray(object) || isMap(object) || isSet(object) || isError(object) || isInstanceOfRegisteredClass(object, superJson);
+function addIdentity(object, path, identities) {
+	const existingSet = identities.get(object);
+	if (existingSet) existingSet.push(path);
+	else identities.set(object, [path]);
+}
+function generateReferentialEqualityAnnotations(identitites, dedupe) {
+	const result = {};
+	let rootEqualityPaths = void 0;
+	identitites.forEach((paths) => {
+		if (paths.length <= 1) return;
+		if (!dedupe) paths = paths.map((path) => path.map(String)).sort((a, b) => a.length - b.length);
+		const [representativePath, ...identicalPaths] = paths;
+		if (representativePath.length === 0) rootEqualityPaths = identicalPaths.map(stringifyPath);
+		else result[stringifyPath(representativePath)] = identicalPaths.map(stringifyPath);
+	});
+	if (rootEqualityPaths) if (isEmptyObject(result)) return [rootEqualityPaths];
+	else return [rootEqualityPaths, result];
+	else return isEmptyObject(result) ? void 0 : result;
+}
+var walker = (object, identities, superJson, dedupe, path = [], objectsInThisPath = [], seenObjects = /* @__PURE__ */ new Map()) => {
+	const primitive = isPrimitive(object);
+	if (!primitive) {
+		addIdentity(object, path, identities);
+		const seen = seenObjects.get(object);
+		if (seen) return dedupe ? { transformedValue: null } : seen;
+	}
+	if (!isDeep(object, superJson)) {
+		const transformed = transformValue(object, superJson);
+		const result = transformed ? {
+			transformedValue: transformed.value,
+			annotations: [transformed.type]
+		} : { transformedValue: object };
+		if (!primitive) seenObjects.set(object, result);
+		return result;
+	}
+	if (includes(objectsInThisPath, object)) return { transformedValue: null };
+	const transformationResult = transformValue(object, superJson);
+	const transformed = transformationResult?.value ?? object;
+	const transformedValue = isArray(transformed) ? [] : {};
+	const innerAnnotations = {};
+	forEach(transformed, (value, index) => {
+		if (index === "__proto__" || index === "constructor" || index === "prototype") throw new Error(`Detected property ${index}. This is a prototype pollution risk, please remove it from your object.`);
+		const recursiveResult = walker(value, identities, superJson, dedupe, [...path, index], [...objectsInThisPath, object], seenObjects);
+		transformedValue[index] = recursiveResult.transformedValue;
+		if (isArray(recursiveResult.annotations)) innerAnnotations[escapeKey(index)] = recursiveResult.annotations;
+		else if (isPlainObject(recursiveResult.annotations)) forEach(recursiveResult.annotations, (tree, key) => {
+			innerAnnotations[escapeKey(index) + "." + key] = tree;
+		});
+	});
+	const result = isEmptyObject(innerAnnotations) ? {
+		transformedValue,
+		annotations: !!transformationResult ? [transformationResult.type] : void 0
+	} : {
+		transformedValue,
+		annotations: !!transformationResult ? [transformationResult.type, innerAnnotations] : innerAnnotations
+	};
+	if (!primitive) seenObjects.set(object, result);
+	return result;
+};
+//#endregion
+export { applyReferentialEqualityAnnotations, applyValueAnnotations, generateReferentialEqualityAnnotations, walker };

package/dist/ui/node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/registry.qwik.mjs

@@ -0,0 +1,24 @@
+import { DoubleIndexedKV } from "./double-indexed-kv.qwik.mjs";
+//#region ../../node_modules/.pnpm/superjson@2.2.6/node_modules/superjson/dist/registry.js
+var Registry = class {
+	constructor(generateIdentifier) {
+		this.generateIdentifier = generateIdentifier;
+		this.kv = new DoubleIndexedKV();
+	}
+	register(value, identifier) {
+		if (this.kv.getByValue(value)) return;
+		if (!identifier) identifier = this.generateIdentifier(value);
+		this.kv.set(identifier, value);
+	}
+	clear() {
+		this.kv.clear();
+	}
+	getIdentifier(value) {
+		return this.kv.getByValue(value);
+	}
+	getValue(identifier) {
+		return this.kv.getByKey(identifier);
+	}
+};
+//#endregion
+export { Registry };