@fgv/ts-res 5.0.1-8 → 5.0.1

package/dist/packlets/common/validate/conditions.js

@@ -0,0 +1,544 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+import { fail, succeed } from '@fgv/ts-utils';
+import { NoMatch, PerfectMatch, MinConditionPriority, MaxConditionPriority, allConditionOperators } from '../conditions';
+import { conditionKey, conditionSetHash, conditionToken, contextToken, decisionKey, identifier, qualifierDefaultValueToken, qualifierDefaultValuesToken } from './regularExpressions';
+/**
+ * Determines whether a string is a valid qualifier name.
+ * @param name - the string to validate
+ * @returns true if the string is a valid qualifier name, false otherwise.
+ * @public
+ */
+export function isValidQualifierName(name) {
+    return identifier.test(name);
+}
+/***
+ * Determines whether a string is a valid qualifier type name.
+ * @param name - the string to validate
+ * @returns true if the string is a valid qualifier type name, false otherwise.
+ * @public
+ */
+export function isValidQualifierTypeName(name) {
+    return identifier.test(name);
+}
+/**
+ * Determines whether a number is a valid priority.
+ * @param priority - the number to validate
+ * @returns true if the number is a valid priority, false otherwise.
+ * @public
+ */
+export function isValidConditionPriority(priority) {
+    return priority >= MinConditionPriority && priority <= MaxConditionPriority;
+}
+/**
+ * Determines whether a number is a valid qualifier index.
+ * @param index - the number to validate
+ * @returns true if the number is a valid qualifier index, false otherwise.
+ * @public
+ */
+export function isValidQualifierIndex(index) {
+    return index >= 0;
+}
+/**
+ * Determines whether a number is a valid qualifier type index.
+ * @param index - the number to validate
+ * @returns true if the number is a valid qualifier type index, false otherwise.
+ * @public
+ */
+export function isValidQualifierTypeIndex(index) {
+    return index >= 0;
+}
+/**
+ * Determines whether a supplied value is a valid {@link QualifierMatchScore | match score}.
+ * @param value - The value to validate.
+ * @returns - `true` if the value is a valid match score, `false` otherwise.
+ * @public
+ */
+export function isValidQualifierMatchScore(value) {
+    return value >= NoMatch && value <= PerfectMatch;
+}
+/**
+ * Determines whether a number is a valid condition index.
+ * @param index - the number to validate
+ * @returns true if the number is a valid condition index, false otherwise.
+ * @public
+ */
+export function isValidConditionIndex(index) {
+    return index >= 0;
+}
+/**
+ * Determines whether a string is a valid condition operator.
+ * @param operator - the string to validate
+ * @returns true if the string is a valid condition operator, false otherwise.
+ * @public
+ */
+export function isValidConditionOperator(operator) {
+    return allConditionOperators.includes(operator);
+}
+/**
+ * Determines whether a string is a valid condition key.  A condition key has
+ * the format:
+ * `<qualifierName>(-<operator>)?-[<value>]@<priority>`
+ * where operator is omitted for the default 'matches' operator.
+ * @param key - the string to validate
+ * @returns `true` if the string is a valid condition key, `false` otherwise.
+ * @public
+ */
+export function isValidConditionKey(key) {
+    return conditionKey.test(key);
+}
+/**
+ * Determines whether a string is a valid {@link ConditionToken | condition token}.
+ * A condition token has the format:
+ * `<qualifierName>=<value>` or `<value>`
+ * @param token -
+ * @returns `true` if the string is a valid condition token, `false` otherwise.
+ * @public
+ */
+export function isValidConditionToken(token) {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (token === '') {
+        return true;
+    }
+    return conditionToken.test(token);
+}
+/**
+ * Determines whether a number is a valid condition set index.
+ * @param index - the number to validate
+ * @returns true if the number is a valid condition set index, false otherwise.
+ * @public
+ */
+export function isValidConditionSetIndex(index) {
+    return index >= 0;
+}
+/**
+ * Determines whether a string is a valid condition set key.
+ * @param key - the string to validate.
+ * @returns `true` if the string is a valid condition set key, `false` otherwise.
+ * @public
+ */
+export function isValidConditionSetKey(key) {
+    if (key === '') {
+        return true;
+    }
+    /* c8 ignore next 2 - edge case: condition set key validation rarely fails */
+    // a condition set key is a `+` separated list of condition keys
+    return key.split('+').every(isValidConditionKey);
+}
+/**
+ * Determines whether a string is a valid condition set token.
+ * @param token - the string to validate.
+ * @returns `true` if the string is a valid condition set token, `false` otherwise.
+ * @public
+ */
+export function isValidConditionSetToken(token) {
+    return token.split(',').every(isValidConditionToken);
+}
+/**
+ * Determines whether a string is a valid condition set hash.
+ * @param hash - the string to validate.
+ * @returns `true` if the string is a valid condition set hash, `false` otherwise.
+ * @public
+ */
+export function isValidConditionSetHash(hash) {
+    return conditionSetHash.test(hash);
+}
+/**
+ * Determines whether a string is a valid decision key.
+ * @param key - the string to validate
+ * @returns `true` if the string is a valid decision key, `false` otherwise.
+ * @public
+ */
+export function isValidDecisionKey(key) {
+    if (key === '') {
+        return true;
+    }
+    return decisionKey.test(key);
+}
+/**
+ * Determines whether a number is a valid decision index.
+ * @param index - the number to validate
+ * @returns `true` if the number is a valid decision index, `false` otherwise.
+ * @public
+ */
+export function isValidDecisionIndex(index) {
+    return index >= 0;
+}
+/**
+ * Determines whether a string is a valid qualifier context value.
+ * For now, any non-empty string is considered a valid context value.
+ * @param value - the string to validate
+ * @returns true if the string is a valid qualifier context value, false otherwise.
+ * @public
+ */
+export function isValidQualifierContextValue(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+/**
+ * Converts a string to a {@link QualifierName} if it is a valid qualifier name.
+ * @param name - the string to convert
+ * @returns `Success` with the converted {@link QualifierName} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toQualifierName(name) {
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (!isValidQualifierName(name)) {
+        return fail(`${name}: invalid qualifier name`);
+    }
+    return succeed(name);
+}
+/**
+ * Converts a string to a {@link QualifierContextValue} if it is a valid qualifier context value.
+ * @param value - the string to convert
+ * @returns `Success` with the converted {@link QualifierContextValue} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toQualifierContextValue(value) {
+    if (!isValidQualifierContextValue(value)) {
+        return fail(`${value}: invalid qualifier context value`);
+    }
+    return succeed(value);
+}
+/**
+ * Converts a number to a {@link QualifierIndex} if it is a valid qualifier index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link QualifierIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toQualifierIndex(index) {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!isValidQualifierIndex(index)) {
+        return fail(`${index}: invalid qualifier index`);
+    }
+    return succeed(index);
+}
+/**
+ * Converts a string to a {@link QualifierTypeName} if it is a valid qualifier type name.
+ * @param name - the string to convert
+ * @returns `Success` with the converted {@link QualifierTypeName} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toQualifierTypeName(name) {
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (!isValidQualifierTypeName(name)) {
+        return fail(`${name}: invalid qualifier type name`);
+    }
+    return succeed(name);
+}
+/**
+ * Converts a number to a {@link QualifierTypeIndex} if it is a valid qualifier type index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link QualifierTypeIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toQualifierTypeIndex(index) {
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (!isValidQualifierTypeIndex(index)) {
+        return fail(`${index}: invalid qualifier type index`);
+    }
+    return succeed(index);
+}
+/**
+ * Converts a number to a {@link QualifierMatchScore | match score} if it is a valid score.
+ * @param value - The number to convert.
+ * @returns `Success` with the converted score if successful, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+export function toQualifierMatchScore(value) {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!isValidQualifierMatchScore(value)) {
+        return fail(`${value}: invalid match score`);
+    }
+    return succeed(value);
+}
+/**
+ * Converts a number to a {@link ConditionPriority} if it is a valid priority.
+ * @param priority - the number to convert
+ * @returns `Success` with the converted {@link ConditionPriority} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toConditionPriority(priority) {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!isValidConditionPriority(priority)) {
+        return fail(`${priority}: invalid priority`);
+    }
+    return succeed(priority);
+}
+/**
+ * Converts a number to a {@link ConditionIndex} if it is a valid condition index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link ConditionIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toConditionIndex(index) {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!isValidConditionIndex(index)) {
+        return fail(`${index}: invalid condition index`);
+    }
+    return succeed(index);
+}
+/**
+ * Converts a string to a {@link ConditionOperator} if it is a valid condition operator.
+ * @param operator - the string to convert
+ * @returns `Success` with the converted {@link ConditionOperator} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toConditionOperator(operator) {
+    if (!isValidConditionOperator(operator)) {
+        return fail(`${operator}: invalid condition operator`);
+    }
+    return succeed(operator);
+}
+/**
+ * Converts a string to a {@link ConditionKey} if it is a valid condition key.
+ * @param key - the string to convert
+ * @returns `Success` with the converted {@link ConditionKey} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toConditionKey(key) {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!isValidConditionKey(key)) {
+        return fail(`${key}: invalid condition key`);
+    }
+    return succeed(key);
+}
+/**
+ * Converts a string to a {@link ConditionToken} if it is a valid condition token.
+ * @param token - the string to convert
+ * @returns `Success` with the converted {@link ConditionToken} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toConditionToken(token) {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!isValidConditionToken(token)) {
+        return fail(`${token}: invalid condition token`);
+    }
+    return succeed(token);
+}
+/**
+ * Converts a number to a {@link ConditionSetIndex} if it is a valid condition set index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link ConditionSetIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toConditionSetIndex(index) {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!isValidConditionSetIndex(index)) {
+        return fail(`${index}: invalid condition set index`);
+    }
+    return succeed(index);
+}
+/**
+ * Converts a string to a {@link ConditionSetKey} if it is a valid condition set key.
+ * @param key - the string to convert
+ * @returns `Success` with the converted {@link ConditionSetKey} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toConditionSetKey(key) {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!isValidConditionSetKey(key)) {
+        return fail(`${key}: invalid condition set key`);
+    }
+    return succeed(key);
+}
+/**
+ * Converts a string to a {@link ConditionSetToken} if it is a valid condition set token.
+ * @param token - the string to convert
+ * @returns `Success` with the converted {@link ConditionSetToken} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toConditionSetToken(token) {
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (!isValidConditionSetToken(token)) {
+        return fail(`${token}: invalid condition set token`);
+    }
+    return succeed(token);
+}
+/**
+ * Converts a string to a {@link ConditionSetHash} if it is a valid condition set hash.
+ * @param key - the string to convert
+ * @returns `Success` with the converted {@link ConditionSetHash} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toConditionSetHash(hash) {
+    if (!isValidConditionSetHash(hash)) {
+        return fail(`${hash}: invalid condition set hash`);
+    }
+    return succeed(hash);
+}
+/**
+ * Converts a number to a {@link DecisionIndex} if it is a valid decision index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link DecisionIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toDecisionKey(key) {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!isValidDecisionKey(key)) {
+        return fail(`${key}: invalid decision key`);
+    }
+    return succeed(key);
+}
+/**
+ * Converts a number to a {@link DecisionIndex} if it is a valid decision index.
+ * @param index - the number to convert
+ * @returns `Success` with the converted {@link DecisionIndex} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toDecisionIndex(index) {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!isValidDecisionIndex(index)) {
+        return fail(`${index}: invalid decision index`);
+    }
+    return succeed(index);
+}
+/**
+ * Determines whether a string is a valid {@link ContextQualifierToken | context qualifier token}.
+ * A context qualifier token has the format:
+ * `<qualifierName>=<value>` or `<value>`
+ * Context qualifier tokens allow broader character set including commas for comma-separated values.
+ * @param token - the string to validate
+ * @returns `true` if the string is a valid context qualifier token, `false` otherwise.
+ * @public
+ */
+export function isValidContextQualifierToken(token) {
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (token === '') {
+        return true;
+    }
+    return contextToken.test(token);
+}
+/**
+ * Determines whether a string is a valid context token.
+ * Context tokens are pipe-separated lists of context qualifier tokens.
+ * @param token - the string to validate.
+ * @returns `true` if the string is a valid context token, `false` otherwise.
+ * @public
+ */
+export function isValidContextToken(token) {
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (token === '') {
+        return true;
+    }
+    const parts = token.split('|').map((part) => part.trim());
+    return parts.every((part) => part !== '' && isValidContextQualifierToken(part));
+}
+/**
+ * Converts a string to a {@link ContextQualifierToken} if it is a valid context qualifier token.
+ * @param token - the string to convert
+ * @returns `Success` with the converted {@link ContextQualifierToken} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toContextQualifierToken(token) {
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (!isValidContextQualifierToken(token)) {
+        return fail(`${token}: invalid context qualifier token`);
+    }
+    return succeed(token);
+}
+/**
+ * Converts a string to a {@link ContextToken} if it is a valid context token.
+ * @param token - the string to convert
+ * @returns `Success` with the converted {@link ContextToken} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toContextToken(token) {
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (!isValidContextToken(token)) {
+        return fail(`${token}: invalid context token`);
+    }
+    return succeed(token);
+}
+/**
+ * Determines whether a string is a valid {@link QualifierDefaultValueToken | qualifier default value token}.
+ * A qualifier default value token has the format:
+ * `<qualifierName>=<value>` or `<qualifierName>=` (to remove default)
+ * Default values allow broader character set including commas for comma-separated values.
+ * @param token - the string to validate
+ * @returns `true` if the string is a valid qualifier default value token, `false` otherwise.
+ * @public
+ */
+export function isValidQualifierDefaultValueToken(token) {
+    return qualifierDefaultValueToken.test(token);
+}
+/**
+ * Determines whether a string is a valid qualifier default values token.
+ * Qualifier default values tokens are pipe-separated lists of qualifier default value tokens.
+ * @param token - the string to validate.
+ * @returns `true` if the string is a valid qualifier default values token, `false` otherwise.
+ * @public
+ */
+export function isValidQualifierDefaultValuesToken(token) {
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (token === '') {
+        return true;
+    }
+    return qualifierDefaultValuesToken.test(token);
+}
+/**
+ * Converts a string to a {@link QualifierDefaultValueToken} if it is a valid qualifier default value token.
+ * @param token - the string to convert
+ * @returns `Success` with the converted {@link QualifierDefaultValueToken} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toQualifierDefaultValueToken(token) {
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (!isValidQualifierDefaultValueToken(token)) {
+        return fail(`${token}: invalid qualifier default value token`);
+    }
+    return succeed(token);
+}
+/**
+ * Converts a string to a {@link QualifierDefaultValuesToken} if it is a valid qualifier default values token.
+ * @param token - the string to convert
+ * @returns `Success` with the converted {@link QualifierDefaultValuesToken} if successful, or `Failure` with an
+ * error message if not.
+ * @public
+ */
+export function toQualifierDefaultValuesToken(token) {
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (!isValidQualifierDefaultValuesToken(token)) {
+        return fail(`${token}: invalid qualifier default values token`);
+    }
+    return succeed(token);
+}
+//# sourceMappingURL=conditions.js.map

package/dist/packlets/common/validate/index.js

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+export * from './conditions';
+export * from './resources';
+import * as RegularExpressions from './regularExpressions';
+export { RegularExpressions };
+//# sourceMappingURL=index.js.map

package/dist/packlets/common/validate/regularExpressions.js

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/**
+ * @internal
+ */
+export const identifier = /^[a-zA-Z_][a-zA-Z0-9_\-]*$/;
+/**
+ * @internal
+ */
+export const segmentedIdentifier = /^[a-zA-Z_][a-zA-Z0-9_\-]*(\.[a-zA-Z_][a-zA-Z0-9_\-]*)*$/;
+/**
+ * @internal
+ */
+export const identifierList = /^[a-zA-Z_][a-zA-Z0-9_\-]*(,[a-zA-Z_][a-zA-Z0-9_\-]*)*$/;
+/**
+ * The format of a {@link ConditionKey | condition key} is:
+ * <qualifierName>-[<value>][\@<priority>](<scoreAsDefault>) where operator is `matches`, or
+ * <qualifierName>-<operator>-[<value>][\@<priority>](<scoreAsDefault>)
+ * @internal
+ */
+export const conditionKey = /^[a-zA-Z_][a-zA-Z0-9_\-]*(-matches)?-\[.*\](?:@[0-9]{1,4})?(?:\([01](?:\.[0-9]+)?\))?$/;
+/**
+ * A {@link ConditionToken | condition token} is a comma-separated list of one or more
+ * condition specifiers, where a condition specifier has either the form
+ * `<qualifierName>=<value>` or `<value>`.
+ * @internal
+ */
+export const conditionToken = /^[a-zA-Z_][a-zA-Z0-9_\-]*(?:=[a-zA-Z0-9_\-]+)?$/;
+/**
+ * A {@link ContextToken | context token} has the form `<qualifierName>=<value>` or `<value>`.
+ * Context tokens allow broader character set including commas for comma-separated values.
+ * @internal
+ */
+export const contextToken = /^[a-zA-Z_][a-zA-Z0-9_\-]*(?:=[a-zA-Z0-9_\-,\s]+)?$/;
+/**
+ * @internal
+ */
+export const conditionSetHash = /^[a-zA-Z0-9]{8}$/;
+/**
+ * @internal
+ */
+export const decisionKey = /^[a-zA-Z0-9]{8}(?:\+[a-zA-Z0-9]{8})*(?:\|[a-zA-Z0-9]{8})?$/;
+/**
+ * @internal
+ */
+export const candidateValueKey = /^[a-zA-Z0-9]+$/;
+/**
+ * A {@link QualifierDefaultValueToken | qualifier default value token} has the form
+ * `<qualifierName>=<value>` or `<qualifierName>=` (to remove default).
+ * Default values allow broader character set including commas for comma-separated values.
+ * @internal
+ */
+export const qualifierDefaultValueToken = /^[a-zA-Z_][a-zA-Z0-9_\-]*=(?:[a-zA-Z0-9_\-,\s]*)?$/;
+/**
+ * A {@link QualifierDefaultValuesToken | qualifier default values token} is a
+ * pipe-separated list of one or more qualifier default value tokens.
+ * Uses "|" as separator to avoid conflicts with comma-separated values within defaults.
+ * @internal
+ */
+export const qualifierDefaultValuesToken = /^[a-zA-Z_][a-zA-Z0-9_\-]*=(?:[a-zA-Z0-9_\-,\s]*)?(?:\|[a-zA-Z_][a-zA-Z0-9_\-]*=(?:[a-zA-Z0-9_\-,\s]*)?)*$/;
+/**
+ * @internal
+ */
+export const territoryCode = /^[a-zA-Z]{2}$/;
+//# sourceMappingURL=regularExpressions.js.map