z-schema 12.0.4 → 12.1.0

package/dist/schemas/draft-2020-12-meta-format-assertion.mjs

@@ -0,0 +1,11 @@
+//#region src/schemas/draft-2020-12-meta-format-assertion.json
+var draft_2020_12_meta_format_assertion_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/format-assertion",
+	$dynamicAnchor: "meta",
+	title: "Format vocabulary meta-schema for assertion results",
+	type: ["object", "boolean"],
+	properties: { "format": { "type": "string" } }
+};
+//#endregion
+export { draft_2020_12_meta_format_assertion_default as default };

package/dist/schemas/draft-2020-12-meta-meta-data.mjs

@@ -0,0 +1,31 @@
+//#region src/schemas/draft-2020-12-meta-meta-data.json
+var draft_2020_12_meta_meta_data_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/meta-data",
+	$dynamicAnchor: "meta",
+	title: "Meta-data vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"title": { "type": "string" },
+		"description": { "type": "string" },
+		"default": true,
+		"deprecated": {
+			"type": "boolean",
+			"default": false
+		},
+		"readOnly": {
+			"type": "boolean",
+			"default": false
+		},
+		"writeOnly": {
+			"type": "boolean",
+			"default": false
+		},
+		"examples": {
+			"type": "array",
+			"items": true
+		}
+	}
+};
+//#endregion
+export { draft_2020_12_meta_meta_data_default as default };

package/dist/schemas/draft-2020-12-meta-unevaluated.mjs

@@ -0,0 +1,14 @@
+//#region src/schemas/draft-2020-12-meta-unevaluated.json
+var draft_2020_12_meta_unevaluated_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
+	$dynamicAnchor: "meta",
+	title: "Unevaluated applicator vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"unevaluatedItems": { "$dynamicRef": "#meta" },
+		"unevaluatedProperties": { "$dynamicRef": "#meta" }
+	}
+};
+//#endregion
+export { draft_2020_12_meta_unevaluated_default as default };

package/dist/schemas/draft-2020-12-meta-validation.mjs

@@ -0,0 +1,80 @@
+//#region src/schemas/draft-2020-12-meta-validation.json
+var draft_2020_12_meta_validation_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/meta/validation",
+	$dynamicAnchor: "meta",
+	title: "Validation vocabulary meta-schema",
+	type: ["object", "boolean"],
+	properties: {
+		"type": { "anyOf": [{ "$ref": "#/$defs/simpleTypes" }, {
+			"type": "array",
+			"items": { "$ref": "#/$defs/simpleTypes" },
+			"minItems": 1,
+			"uniqueItems": true
+		}] },
+		"const": true,
+		"enum": {
+			"type": "array",
+			"items": true
+		},
+		"multipleOf": {
+			"type": "number",
+			"exclusiveMinimum": 0
+		},
+		"maximum": { "type": "number" },
+		"exclusiveMaximum": { "type": "number" },
+		"minimum": { "type": "number" },
+		"exclusiveMinimum": { "type": "number" },
+		"maxLength": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minLength": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+		"pattern": {
+			"type": "string",
+			"format": "regex"
+		},
+		"maxItems": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minItems": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+		"uniqueItems": {
+			"type": "boolean",
+			"default": false
+		},
+		"maxContains": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minContains": {
+			"$ref": "#/$defs/nonNegativeInteger",
+			"default": 1
+		},
+		"maxProperties": { "$ref": "#/$defs/nonNegativeInteger" },
+		"minProperties": { "$ref": "#/$defs/nonNegativeIntegerDefault0" },
+		"required": { "$ref": "#/$defs/stringArray" },
+		"dependentRequired": {
+			"type": "object",
+			"additionalProperties": { "$ref": "#/$defs/stringArray" }
+		}
+	},
+	$defs: {
+		"nonNegativeInteger": {
+			"type": "integer",
+			"minimum": 0
+		},
+		"nonNegativeIntegerDefault0": {
+			"$ref": "#/$defs/nonNegativeInteger",
+			"default": 0
+		},
+		"simpleTypes": { "enum": [
+			"array",
+			"boolean",
+			"integer",
+			"null",
+			"number",
+			"object",
+			"string"
+		] },
+		"stringArray": {
+			"type": "array",
+			"items": { "type": "string" },
+			"uniqueItems": true,
+			"default": []
+		}
+	}
+};
+//#endregion
+export { draft_2020_12_meta_validation_default as default };

package/dist/schemas/draft-2020-12-schema.mjs

@@ -0,0 +1,55 @@
+//#region src/schemas/draft-2020-12-schema.json
+var draft_2020_12_schema_default = {
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	$id: "https://json-schema.org/draft/2020-12/schema",
+	$vocabulary: {
+		"https://json-schema.org/draft/2020-12/vocab/core": true,
+		"https://json-schema.org/draft/2020-12/vocab/applicator": true,
+		"https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+		"https://json-schema.org/draft/2020-12/vocab/validation": true,
+		"https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+		"https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+		"https://json-schema.org/draft/2020-12/vocab/content": true
+	},
+	$dynamicAnchor: "meta",
+	title: "Core and Validation specifications meta-schema",
+	allOf: [
+		{ "$ref": "meta/core" },
+		{ "$ref": "meta/applicator" },
+		{ "$ref": "meta/unevaluated" },
+		{ "$ref": "meta/validation" },
+		{ "$ref": "meta/meta-data" },
+		{ "$ref": "meta/format-annotation" },
+		{ "$ref": "meta/content" }
+	],
+	type: ["object", "boolean"],
+	$comment: "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+	properties: {
+		"definitions": {
+			"$comment": "\"definitions\" has been replaced by \"$defs\".",
+			"type": "object",
+			"additionalProperties": { "$dynamicRef": "#meta" },
+			"deprecated": true,
+			"default": {}
+		},
+		"dependencies": {
+			"$comment": "\"dependencies\" has been split and replaced by \"dependentSchemas\" and \"dependentRequired\" in order to serve their differing semantics.",
+			"type": "object",
+			"additionalProperties": { "anyOf": [{ "$dynamicRef": "#meta" }, { "$ref": "meta/validation#/$defs/stringArray" }] },
+			"deprecated": true,
+			"default": {}
+		},
+		"$recursiveAnchor": {
+			"$comment": "\"$recursiveAnchor\" has been replaced by \"$dynamicAnchor\".",
+			"$ref": "meta/core#/$defs/anchorString",
+			"deprecated": true
+		},
+		"$recursiveRef": {
+			"$comment": "\"$recursiveRef\" has been replaced by \"$dynamicRef\".",
+			"$ref": "meta/core#/$defs/uriReferenceString",
+			"deprecated": true
+		}
+	}
+};
+//#endregion
+export { draft_2020_12_schema_default as default };

package/dist/utils/array.mjs

@@ -0,0 +1,54 @@
+import { areEqual } from "./json.mjs";
+//#region src/utils/array.ts
+/**
+* Check if all elements in an array are unique.
+*
+* Uses a Set-based fast path for arrays of pure primitives (O(n)).
+* Falls back to pairwise deep comparison (O(n²)) when the array contains
+* objects or arrays that need structural equality checks.
+*/
+const isUniqueArray = (arr, indexes, maxDepth) => {
+	const l = arr.length;
+	if (l <= 1) return true;
+	let allPrimitive = true;
+	for (let i = 0; i < l; i++) {
+		const v = arr[i];
+		if (v !== null && typeof v === "object") {
+			allPrimitive = false;
+			break;
+		}
+	}
+	if (allPrimitive) {
+		const seen = /* @__PURE__ */ new Set();
+		for (let i = 0; i < l; i++) {
+			const v = arr[i];
+			const key = typeof v + ":" + String(v);
+			if (seen.has(key)) {
+				if (indexes) for (let j = 0; j < i; j++) {
+					const prev = arr[j];
+					if (typeof prev === typeof v && prev === v) {
+						indexes.push(j, i);
+						break;
+					}
+				}
+				return false;
+			}
+			seen.add(key);
+		}
+		return true;
+	}
+	for (let i = 0; i < l; i++) for (let j = i + 1; j < l; j++) if (areEqual(arr[i], arr[j], { maxDepth })) {
+		if (indexes) indexes.push(i, j);
+		return false;
+	}
+	return true;
+};
+const difference = (bigSet, subSet) => {
+	const exclusions = new Set(subSet);
+	const arr = [];
+	let idx = bigSet.length;
+	while (idx--) if (!exclusions.has(bigSet[idx])) arr.push(bigSet[idx]);
+	return arr;
+};
+//#endregion
+export { difference, isUniqueArray };

package/dist/utils/base64.mjs

@@ -0,0 +1,21 @@
+//#region src/utils/base64.ts
+const base64Pattern = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const isValidBase64 = (value) => {
+	if (value.length % 4 !== 0) return false;
+	return base64Pattern.test(value);
+};
+const decodeBase64 = (value) => {
+	if (!isValidBase64(value)) return;
+	if (typeof atob === "function") try {
+		return atob(value);
+	} catch {
+		return;
+	}
+	if (typeof Buffer !== "undefined") try {
+		return Buffer.from(value, "base64").toString("utf8");
+	} catch {
+		return;
+	}
+};
+//#endregion
+export { decodeBase64, isValidBase64 };

package/dist/utils/clone.mjs

@@ -0,0 +1,42 @@
+import { copyProp } from "./properties.mjs";
+//#region src/utils/clone.ts
+const shallowClone = (src) => {
+	if (src == null || typeof src !== "object") return src;
+	let res;
+	if (Array.isArray(src)) {
+		res = [];
+		for (let i = 0; i < src.length; i++) res[i] = src[i];
+	} else {
+		res = {};
+		const keys = Object.keys(src).sort();
+		for (const key of keys) copyProp(src, res, key);
+	}
+	return res;
+};
+const deepClone = (src, maxDepth = 100) => {
+	let vidx = 0;
+	const visited = /* @__PURE__ */ new Map();
+	const cloned = [];
+	const cloneDeepInner = (src, _depth) => {
+		if (typeof src !== "object" || src === null) return src;
+		if (_depth >= maxDepth) throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in deepClone. If your schema or data is deeply nested and valid, increase the maxRecursionDepth option.`);
+		let res;
+		const cidx = visited.get(src);
+		if (cidx !== void 0) return cloned[cidx];
+		visited.set(src, vidx++);
+		if (Array.isArray(src)) {
+			res = [];
+			cloned.push(res);
+			for (let i = 0; i < src.length; i++) res[i] = cloneDeepInner(src[i], _depth + 1);
+		} else {
+			res = {};
+			cloned.push(res);
+			const keys = Object.keys(src).sort();
+			for (const key of keys) copyProp(src, res, key, (v) => cloneDeepInner(v, _depth + 1));
+		}
+		return res;
+	};
+	return cloneDeepInner(src, 0);
+};
+//#endregion
+export { deepClone, shallowClone };

package/dist/utils/constants.mjs

@@ -0,0 +1,16 @@
+//#region src/utils/constants.ts
+/**
+* Maximum allowed value for {@link ZSchemaOptions.asyncTimeout} in milliseconds.
+* Values exceeding this limit are clamped during option normalization to
+* prevent resource exhaustion (CWE-400).
+*/
+const MAX_ASYNC_TIMEOUT = 6e4;
+/**
+* Maximum allowed length for a JSON Schema `pattern` regular expression string.
+* Patterns exceeding this limit are rejected by {@link compileSchemaRegex} to
+* mitigate Regular Expression Denial-of-Service (CWE-1333) and regex injection
+* (CWE-95).
+*/
+const MAX_SCHEMA_REGEX_LENGTH = 1e4;
+//#endregion
+export { MAX_ASYNC_TIMEOUT, MAX_SCHEMA_REGEX_LENGTH };

package/dist/utils/date.mjs

@@ -0,0 +1,19 @@
+//#region src/utils/date.ts
+const isLeapYear = (year) => year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+const getDaysInMonth = (year, month) => {
+	switch (month) {
+		case 2: return isLeapYear(year) ? 29 : 28;
+		case 4:
+		case 6:
+		case 9:
+		case 11: return 30;
+		default: return 31;
+	}
+};
+const isValidRfc3339Date = (year, month, day) => {
+	if (month < 1 || month > 12) return false;
+	const maxDay = getDaysInMonth(year, month);
+	return day >= 1 && day <= maxDay;
+};
+//#endregion
+export { isValidRfc3339Date };

package/dist/utils/hostname.mjs

@@ -0,0 +1,73 @@
+import isIPModule from "validator/lib/isIP.js";
+import punycode from "punycode/punycode.js";
+//#region src/utils/hostname.ts
+const IDN_SEPARATOR_REGEX = /[\u3002\uff0e\uff61]/g;
+const IDN_SEPARATOR_TEST_REGEX = /[\u3002\uff0e\uff61]/;
+const splitHostnameLabels = (hostname) => {
+	if (hostname.length === 0 || hostname.length > 255) return null;
+	if (hostname.startsWith(".") || hostname.endsWith(".")) return null;
+	const labels = hostname.split(".");
+	if (labels.some((label) => label.length === 0 || label.length > 63)) return null;
+	return labels;
+};
+const isAsciiHostnameLabel = (label) => /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test(label);
+const isGreek = (char) => /\p{Script=Greek}/u.test(char);
+const isHebrew = (char) => /\p{Script=Hebrew}/u.test(char);
+const hasCjkKanaOrHan = (input) => /[\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Han}]/u.test(input);
+const toUnicodeLabel = (label) => {
+	if (!/^xn--/i.test(label)) return label;
+	try {
+		return punycode.toUnicode(label.toLowerCase());
+	} catch (_e) {
+		return null;
+	}
+};
+const isValidIdnUnicodeLabel = (label) => {
+	if (label.startsWith("-") || label.endsWith("-")) return false;
+	if (label.length >= 4 && label[2] === "-" && label[3] === "-" && !/^xn--/i.test(label)) return false;
+	if (/^\p{M}/u.test(label)) return false;
+	if (/[\u302e\u302f\u0640\u07fa]/u.test(label)) return false;
+	for (let idx = 0; idx < label.length; idx++) {
+		const char = label[idx];
+		if (char === "·") {
+			if (idx === 0 || idx === label.length - 1 || label[idx - 1] !== "l" || label[idx + 1] !== "l") return false;
+		}
+		if (char === "͵") {
+			if (idx === label.length - 1 || !isGreek(label[idx + 1])) return false;
+		}
+		if (char === "׳" || char === "״") {
+			if (idx === 0 || !isHebrew(label[idx - 1])) return false;
+		}
+		if (char === "‍") {
+			if (idx === 0 || label[idx - 1] !== "्") return false;
+		}
+	}
+	if (label.includes("・") && !hasCjkKanaOrHan(label.replace(/\u30fb/g, ""))) return false;
+	const hasArabicIndic = /[\u0660-\u0669]/.test(label);
+	const hasExtendedArabicIndic = /[\u06f0-\u06f9]/.test(label);
+	if (hasArabicIndic && hasExtendedArabicIndic) return false;
+	return true;
+};
+const isValidHostname = (hostname) => {
+	if (IDN_SEPARATOR_TEST_REGEX.test(hostname) || /[^\x00-\x7F]/.test(hostname)) return false;
+	if (isIPModule.default(hostname, 4)) return false;
+	const labels = splitHostnameLabels(hostname);
+	if (labels === null) return false;
+	for (const label of labels) {
+		if (!isAsciiHostnameLabel(label)) return false;
+		const unicodeLabel = toUnicodeLabel(label);
+		if (unicodeLabel === null || !isValidIdnUnicodeLabel(unicodeLabel)) return false;
+	}
+	return true;
+};
+const isValidIdnHostname = (hostname) => {
+	const labels = splitHostnameLabels(hostname.replace(IDN_SEPARATOR_REGEX, "."));
+	if (labels === null) return false;
+	for (const label of labels) {
+		const unicodeLabel = toUnicodeLabel(label);
+		if (unicodeLabel === null || !isValidIdnUnicodeLabel(unicodeLabel)) return false;
+	}
+	return true;
+};
+//#endregion
+export { isValidHostname, isValidIdnHostname };

package/dist/utils/json.mjs

@@ -0,0 +1,34 @@
+import { isObject } from "./what-is.mjs";
+//#region src/utils/json.ts
+const areEqual = (json1, json2, options, _depth = 0) => {
+	const caseInsensitiveComparison = options?.caseInsensitiveComparison || false;
+	const maxDepth = options?.maxDepth ?? 100;
+	if (json1 === json2) return true;
+	if (caseInsensitiveComparison === true && typeof json1 === "string" && typeof json2 === "string" && json1.toUpperCase() === json2.toUpperCase()) return true;
+	if (_depth >= maxDepth) throw new Error(`Maximum recursion depth (${maxDepth}) exceeded in areEqual. If your data is deeply nested and valid, increase the maxRecursionDepth option.`);
+	let i, len;
+	if (Array.isArray(json1) && Array.isArray(json2)) {
+		if (json1.length !== json2.length) return false;
+		len = json1.length;
+		for (i = 0; i < len; i++) if (!areEqual(json1[i], json2[i], options, _depth + 1)) return false;
+		return true;
+	}
+	if (isObject(json1) && isObject(json2)) {
+		const keys1 = sortedKeys(json1);
+		if (!areEqual(keys1, sortedKeys(json2), options, _depth + 1)) return false;
+		len = keys1.length;
+		for (i = 0; i < len; i++) if (!areEqual(json1[keys1[i]], json2[keys1[i]], options, _depth + 1)) return false;
+		return true;
+	}
+	return false;
+};
+const decodeJSONPointer = (str) => {
+	return decodeURIComponent(str).replace(/~[0-1]/g, (x) => x === "~1" ? "/" : "~");
+};
+const sortedKeys = (obj) => Object.keys(obj).sort();
+const get = (obj, path) => {
+	if (typeof path === "string") path = path.split(".");
+	return path.reduce((acc, key) => acc && acc[key] !== void 0 ? acc[key] : void 0, obj);
+};
+//#endregion
+export { areEqual, decodeJSONPointer, get, sortedKeys };

package/dist/utils/properties.mjs

@@ -0,0 +1,11 @@
+//#region src/utils/properties.ts
+function copyProp(from, to, key, fn) {
+	if (Object.hasOwn(from, key)) Object.defineProperty(to, key, {
+		value: fn ? fn(from[key]) : from[key],
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+}
+//#endregion
+export { copyProp };

package/dist/utils/schema-regex.mjs

@@ -0,0 +1,49 @@
+import { MAX_SCHEMA_REGEX_LENGTH } from "./constants.mjs";
+import isSafeRegex from "safe-regex2";
+//#region src/utils/schema-regex.ts
+function compileSchemaRegex(pattern) {
+	if (pattern.length > 1e4) return {
+		ok: false,
+		error: {
+			pattern,
+			message: `Pattern length ${pattern.length} exceeds maximum allowed length of ${MAX_SCHEMA_REGEX_LENGTH}`
+		}
+	};
+	if (!isSafeRegex(pattern)) return {
+		ok: false,
+		error: {
+			pattern,
+			message: "Pattern rejected as potentially unsafe (ReDoS)"
+		}
+	};
+	if (/\\[pP]{/.test(pattern) || /[\u{10000}-\u{10FFFF}]/u.test(pattern) || /\\uD[89AB][0-9A-Fa-f]{2}\\uD[CDEF][0-9A-Fa-f]{2}/.test(pattern)) try {
+		return {
+			ok: true,
+			value: new RegExp(pattern, "u")
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: {
+				pattern,
+				message: e && e.message ? e.message : "Invalid regular expression"
+			}
+		};
+	}
+	else try {
+		return {
+			ok: true,
+			value: new RegExp(pattern)
+		};
+	} catch (e) {
+		return {
+			ok: false,
+			error: {
+				pattern,
+				message: e && e.message ? e.message : "Invalid regular expression"
+			}
+		};
+	}
+}
+//#endregion
+export { compileSchemaRegex };

package/dist/utils/symbols.mjs

@@ -0,0 +1,5 @@
+//#region src/utils/symbols.ts
+const jsonSymbol = Symbol.for("z-schema/json");
+const schemaSymbol = Symbol.for("z-schema/schema");
+//#endregion
+export { jsonSymbol, schemaSymbol };

package/dist/utils/time.mjs

@@ -0,0 +1,42 @@
+//#region src/utils/time.ts
+const toUtcTime = (hour, minute, offsetSign, offsetHour, offsetMinute) => {
+	const localTotalMinutes = hour * 60 + minute;
+	const offsetTotalMinutes = offsetHour * 60 + offsetMinute;
+	const normalizedUtcTotalMinutes = ((offsetSign === "+" ? localTotalMinutes - offsetTotalMinutes : localTotalMinutes + offsetTotalMinutes) % 1440 + 1440) % 1440;
+	return {
+		hour: Math.floor(normalizedUtcTotalMinutes / 60),
+		minute: normalizedUtcTotalMinutes % 60
+	};
+};
+const RFC3339_TIME_REGEX = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(\.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/i;
+const parseRfc3339Time = (time) => {
+	const matches = RFC3339_TIME_REGEX.exec(time);
+	if (matches === null) return null;
+	const hour = parseInt(matches[1], 10);
+	const minute = parseInt(matches[2], 10);
+	const second = parseInt(matches[3], 10);
+	if (hour > 23 || minute > 59 || second > 60) return null;
+	let utcHour = hour;
+	let utcMinute = minute;
+	if (matches[5].toLowerCase() !== "z") {
+		const offsetMatches = /^([+-])([0-9]{2}):([0-9]{2})$/.exec(matches[5]);
+		if (offsetMatches === null) return null;
+		const offsetSign = offsetMatches[1];
+		const offsetHour = parseInt(offsetMatches[2], 10);
+		const offsetMinute = parseInt(offsetMatches[3], 10);
+		if (offsetHour > 23 || offsetMinute > 59) return null;
+		const utc = toUtcTime(hour, minute, offsetSign, offsetHour, offsetMinute);
+		utcHour = utc.hour;
+		utcMinute = utc.minute;
+	}
+	if (second === 60 && (utcHour !== 23 || utcMinute !== 59)) return null;
+	return {
+		hour,
+		minute,
+		second,
+		utcHour,
+		utcMinute
+	};
+};
+//#endregion
+export { parseRfc3339Time };

package/dist/utils/unicode.mjs

@@ -0,0 +1,12 @@
+//#region src/utils/unicode.ts
+/**
+* Returns the number of Unicode code points in the string.
+* Uses the built-in string iterator which correctly handles surrogate pairs.
+*/
+function unicodeLength(str) {
+	let count = 0;
+	for (const _cp of str) count++;
+	return count;
+}
+//#endregion
+export { unicodeLength };

package/dist/utils/uri.mjs

@@ -0,0 +1,12 @@
+//#region src/utils/uri.ts
+const getQueryPath = (uri) => {
+	const io = uri.indexOf("#");
+	return io === -1 ? void 0 : uri.slice(io + 1);
+};
+const getRemotePath = (uri) => {
+	const io = uri.indexOf("#");
+	return io === -1 ? uri : uri.slice(0, io);
+};
+const isAbsoluteUri = (uri) => /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(uri);
+//#endregion
+export { getQueryPath, getRemotePath, isAbsoluteUri };

package/dist/utils/what-is.mjs

@@ -0,0 +1,23 @@
+//#region src/utils/what-is.ts
+const whatIs = (what) => {
+	if (typeof what === "object") {
+		if (what === null) return "null";
+		if (Array.isArray(what)) return "array";
+		return "object";
+	}
+	if (typeof what === "number") {
+		if (Number.isFinite(what)) if (what % 1 === 0) return "integer";
+		else return "number";
+		if (Number.isNaN(what)) return "not-a-number";
+		return "unknown-number";
+	}
+	return typeof what;
+};
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isInteger(value) {
+	return typeof value === "number" && Number.isFinite(value) && value % 1 === 0;
+}
+//#endregion
+export { isInteger, isObject, whatIs };