@fgv/ts-res 5.0.1-9 → 5.0.1

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

@@ -0,0 +1,209 @@
+/*
+ * 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 { candidateValueKey, identifier, segmentedIdentifier } from './regularExpressions';
+/**
+ * Checks if the given name is a valid resource name.
+ *
+ * @param name - The name to validate.
+ * @returns `true` if the name is a valid resource name, otherwise `false`.
+ * @public
+ */
+export function isValidResourceName(name) {
+    return identifier.test(name);
+}
+/**
+ * Checks if the given ID is a valid resource ID.
+ *
+ * @param id - The ID to validate.
+ * @returns `true` if the ID is a valid resource ID, otherwise `false`.
+ * @public
+ */
+export function isValidResourceId(id) {
+    return segmentedIdentifier.test(id);
+}
+/**
+ * Checks if the given index is a valid resource index.
+ *
+ * @param index - The index to validate.
+ * @returns `true` if the index is a valid resource index, otherwise `false`.
+ * @public
+ */
+export function isValidResourceIndex(index) {
+    return index >= 0;
+}
+/**
+ * Checks if the given name is a valid resource type name.
+ *
+ * @param name - The name to validate.
+ * @returns `true` if the name is a valid resource type name, otherwise `false`.
+ * @public
+ */
+export function isValidResourceTypeName(name) {
+    return identifier.test(name);
+}
+/**
+ * Checks if the given index is a valid resource type index.
+ *
+ * @param index - The index to validate.
+ * @returns `true` if the index is a valid resource type index, otherwise `false`.
+ * @public
+ */
+export function isValidResourceTypeIndex(index) {
+    return index >= 0;
+}
+/**
+ * Checks if the given index is a valid candidate value index.
+ *
+ * @param index - The index to validate.
+ * @returns `true` if the index is a valid candidate value index, otherwise `false`.
+ * @public
+ */
+export function isValidCandidateValueIndex(index) {
+    return index >= 0;
+}
+/**
+ * Checks if the given key is a valid candidate value key.
+ *
+ * @param key - The key to validate.
+ * @returns `true` if the key is a valid candidate value key, otherwise `false`.
+ * @public
+ */
+export function isValidCandidateValueKey(key) {
+    return candidateValueKey.test(key);
+}
+/**
+ * Converts a string to a {@link ResourceName | resource name}.
+ *
+ * @param id - The string to convert.
+ * @returns `Success` with the converted name if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+export function toResourceName(name) {
+    /* c8 ignore next 3 - coverage having issues */
+    if (!isValidResourceName(name)) {
+        return fail(`${name}: invalid resource name.`);
+    }
+    return succeed(name);
+}
+/**
+ * Converts a string to a {@link ResourceId | resource ID}.
+ *
+ * @param id - The string to convert.
+ * @returns `Success` with the converted ID if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+export function toResourceId(id) {
+    /* c8 ignore next 3 - defensive coding: resource ID validation should prevent invalid IDs */
+    if (!isValidResourceId(id)) {
+        return fail(`${id}: invalid resource ID.`);
+    }
+    return succeed(id);
+}
+/**
+ * Converts an optional string to an optional {@link ResourceId | resource ID}.
+ *
+ * @param id - The string to convert.
+ * @returns `Success` with the converted ID if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+export function toOptionalResourceId(id) {
+    return id ? toResourceId(id) : succeed(undefined);
+}
+/**
+ * Converts a number to a {@link ResourceIndex | resource index}.
+ *
+ * @param index - The number to convert.
+ * @returns `Success` with the converted index if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+export function toResourceIndex(index) {
+    if (!isValidResourceIndex(index)) {
+        return fail(`${index}: invalid resource index.`);
+    }
+    return succeed(index);
+}
+/**
+ * Converts a string to a {@link ResourceTypeName | resource type name}.
+ *
+ * @param name - The string to convert.
+ * @returns `Success` with the converted name if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+export function toResourceTypeName(name) {
+    /* c8 ignore next 3 - coverage having issues */
+    if (!isValidResourceTypeName(name)) {
+        return fail(`${name}: invalid resource type name.`);
+    }
+    return succeed(name);
+}
+/**
+ * Converts a number to a {@link ResourceTypeIndex | resource type index}.
+ *
+ * @param index - The number to convert.
+ * @returns `Success` with the converted index if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+export function toResourceTypeIndex(index) {
+    /* c8 ignore next 3 - coverage having issues */
+    if (!isValidResourceTypeIndex(index)) {
+        return fail(`${index}: invalid resource type index.`);
+    }
+    return succeed(index);
+}
+/**
+ * Converts a string to a {@link CandidateValueKey | candidate value key}.
+ *
+ * @param key - The key to convert.
+ * @returns `Success` with the converted key if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+export function toCandidateValueKey(key) {
+    /* c8 ignore next 3 - coverage having issues */
+    if (!isValidCandidateValueKey(key)) {
+        return fail(`${key}: invalid candidate value key.`);
+    }
+    return succeed(key);
+}
+/**
+ * Converts a number to a {@link CandidateValueIndex | candidate value index}.
+ *
+ * @param index - The number to convert.
+ * @returns `Success` with the converted index if valid, or `Failure` with an error message
+ * if not.
+ * @public
+ */
+export function toCandidateValueIndex(index) {
+    /* c8 ignore next 3 - coverage having issues */
+    if (!isValidCandidateValueIndex(index)) {
+        return fail(`${index}: invalid candidate value index.`);
+    }
+    return succeed(index);
+}
+//# sourceMappingURL=resources.js.map

package/dist/packlets/conditions/condition.js

@@ -0,0 +1,252 @@
+/*
+ * 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 { captureResult, Collections, fail } from '@fgv/ts-utils';
+import { Convert as CommonConvert, NoMatch, Validate } from '../common';
+// eslint-disable-next-line @rushstack/typedef-var
+const scoreFormatter = new Intl.NumberFormat('en-US', { minimumFractionDigits: 0, maximumFractionDigits: 3 });
+/**
+ * Represents a single condition applied to some resource instance.
+ * @public
+ */
+export class Condition {
+    /**
+     * Constructs a new {@link Conditions.Condition | Condition} object.
+     * @param qualifier - The {@link Qualifiers.Qualifier | qualifier} used in this condition.
+     * @param value - The value to be matched in this condition.
+     * @param operator - The {@link ConditionOperator | operator} used when matching context value to condition value.
+     * @param priority - The {@link ConditionPriority | relative priority} of this condition.
+     * @param scoreAsDefault - The {@link QualifierMatchScore | score} to be used when this condition is the default.
+     * @param index - The index of this condition.
+     * @public
+     */
+    constructor({ qualifier, value, operator, priority, scoreAsDefault, index }) {
+        if (scoreAsDefault === undefined && qualifier.defaultValue !== undefined) {
+            /* c8 ignore next 4 - edge case: default value matching logic rarely triggered */
+            const defaultMatch = qualifier.type.matches(value, qualifier.defaultValue, 'matches');
+            if (defaultMatch !== NoMatch) {
+                scoreAsDefault = defaultMatch;
+            }
+        }
+        this.qualifier = qualifier;
+        this.operator = operator;
+        this.value = qualifier.validateCondition(value, operator).orThrow();
+        this.priority = priority;
+        this.scoreAsDefault = scoreAsDefault;
+        this._collectible = new Collections.Collectible({
+            key: this.toKey(),
+            index,
+            indexConverter: CommonConvert.conditionIndex
+        });
+    }
+    get key() {
+        return this._collectible.key;
+    }
+    get index() {
+        return this._collectible.index;
+    }
+    setIndex(index) {
+        return this._collectible.setIndex(index);
+    }
+    /**
+     * Creates a new {@link Conditions.Condition | Condition} object from the supplied
+     * {@link Conditions.IValidatedConditionDecl | validated condition declaration}.
+     * @param decl - The {@link Conditions.IValidatedConditionDecl | validated condition declaration}
+     * describing the condition to create.
+     * @returns `Success` with the new {@link Conditions.Condition | Condition} if successful,
+     * `Failure` otherwise.
+     * @public
+     */
+    static create(decl) {
+        return captureResult(() => new Condition(decl));
+    }
+    /**
+     * Determines if this condition matches the supplied {@link Context.IValidatedContextDecl | validated context}.
+     * @param context - The {@link Context.IValidatedContextDecl | context} to match against.
+     * @param options - The {@link Context.IContextMatchOptions | options} to use when matching the context.
+     * @returns A {@link QualifierMatchScore | match score} indicating match quality if the condition is present
+     * in the context to be matched, `undefined` otherwise.
+     * @remarks
+     * If {@link Context.IContextMatchOptions.partialContextMatch | `options.partialContextMatch``} is `true`, then
+     * the method will return `undefined` if the corresponding qualifier is not present in the context.
+     */
+    getContextMatch(context, options) {
+        options = options !== null && options !== void 0 ? options : {};
+        if (this.qualifier.name in context) {
+            const contextValue = context[this.qualifier.name];
+            const match = this.qualifier.type.matches(this.value, contextValue, this.operator);
+            if (match === NoMatch && options.acceptDefaultScore === true && this.scoreAsDefault !== undefined) {
+                return this.scoreAsDefault;
+            }
+            return match;
+        }
+        return options.partialContextMatch === true ? undefined : NoMatch;
+    }
+    /**
+     * Determines if this condition can match the supplied context, even if the context is partial.
+     *
+     * Returns true if:
+     * - The qualifier specified in the condition is not present in the context
+     * - The qualifier is present and matches the condition
+     *
+     * Returns false if:
+     * - The qualifier is present in the context and does not match the condition
+     *
+     * @param context - The context to match against.
+     * @param options - Options to use when matching the context.
+     * @returns `true` if the condition can match the (possibly partial) context, `false` otherwise.
+     * @public
+     */
+    canMatchPartialContext(context, options) {
+        var _a;
+        /* c8 ignore next 1 - defense in depth */
+        const scoreAsDefault = (_a = this.scoreAsDefault) !== null && _a !== void 0 ? _a : NoMatch;
+        if (!(this.qualifier.name in context) || scoreAsDefault > NoMatch) {
+            return true;
+        }
+        return this.qualifier.type.isPotentialMatch(this.value, context[this.qualifier.name]);
+    }
+    /**
+     * Compares two conditions for sorting purposes.
+     * @param c1 - The first {@link Conditions.Condition | condition} to compare.
+     * @param c2 - The second {@link Conditions.Condition | condition} to compare.
+     * @returns A negative number if c1 should come before c2, a positive number
+     * if c2 should come before c1, or zero if they are equivalent.
+     * @public
+     */
+    static compare(c1, c2) {
+        var _a, _b;
+        let diff = c1.priority - c2.priority;
+        diff = diff === 0 ? ((_a = c1.scoreAsDefault) !== null && _a !== void 0 ? _a : 0) - ((_b = c2.scoreAsDefault) !== null && _b !== void 0 ? _b : 0) : diff;
+        diff = diff === 0 ? c1.qualifier.name.localeCompare(c2.qualifier.name) : diff;
+        diff = diff === 0 ? c1.value.localeCompare(c2.value) : diff;
+        return diff;
+    }
+    /**
+     * Gets a {@link ConditionToken | condition token} for this condition, if possible.
+     * It is not possible to get a token for a condition with an operator other than `matches`,
+     * with other-than-default priority, or with a name or value that contains other than alphanumeric
+     * characters, underscore or non-leading hyphen.
+     * @param terse - if `true` and if the qualifier token is optional, the token will be omitted
+     * from the generated {@link ConditionToken | condition token}.
+     * @returns
+     */
+    toToken(terse) {
+        var _a;
+        /* c8 ignore next 3 - defense in depth very difficult to induce */
+        if (this.operator !== 'matches') {
+            return fail(`${this.operator}: cannot create condition token for operator other than 'matches'`);
+        }
+        if (this.priority !== this.qualifier.defaultPriority) {
+            return fail(`${this.priority}: cannot create condition token for non-default priority`);
+        }
+        if (terse && this.qualifier.tokenIsOptional) {
+            return Validate.toConditionToken(this.value);
+        }
+        /* c8 ignore next 1 - coverage having a bad day */
+        const name = (_a = this.qualifier.token) !== null && _a !== void 0 ? _a : this.qualifier.name;
+        return Validate.toConditionToken(`${name}=${this.value}`);
+    }
+    /**
+     * Gets the {@link ConditionKey | key} for this condition.
+     * @returns -
+     */
+    toKey() {
+        return Condition.getKeyForDecl(this).orThrow();
+    }
+    /**
+     * Get a human-readable string representation of the condition.
+     * @returns A string representation of the condition.
+     * @public
+     */
+    toString() {
+        return this.toKey();
+    }
+    /**
+     * Gets the {@link ResourceJson.Json.IChildConditionDecl | child condition declaration} for this condition.
+     * @param options - The {@link ResourceJson.Helpers.IDeclarationOptions | options} to use when creating the child
+     * condition declaration.
+     * @returns The {@link ResourceJson.Json.IChildConditionDecl | child condition declaration} for this condition.
+     * @public
+     */
+    toChildConditionDecl(options) {
+        const showDefaults = (options === null || options === void 0 ? void 0 : options.showDefaults) === true;
+        return Object.assign(Object.assign(Object.assign({ value: this.value }, (showDefaults || this.operator !== 'matches' ? { operator: this.operator } : {})), (showDefaults || this.priority !== this.qualifier.defaultPriority
+            ? { priority: this.priority }
+            : {})), (this.scoreAsDefault ? { scoreAsDefault: this.scoreAsDefault } : {}));
+    }
+    /**
+     * Gets the value for this condition, or the {@link ResourceJson.Json.IChildConditionDecl | child condition declaration}
+     * if the condition has non-default operator, priority or a score as default.
+     * @param options - The {@link ResourceJson.Helpers.IDeclarationOptions | options} to use when creating the child
+     * condition declaration.
+     * @returns A string value for this condition, or the {@link ResourceJson.Json.IChildConditionDecl | child condition declaration}
+     * if the condition has non-default operator, priority or a score as default.
+     */
+    toValueOrChildConditionDecl(options) {
+        if ((options === null || options === void 0 ? void 0 : options.showDefaults) !== true &&
+            this.operator === 'matches' &&
+            this.priority === this.qualifier.defaultPriority &&
+            this.scoreAsDefault === undefined) {
+            return this.value;
+        }
+        /* c8 ignore next 2 - unreachable: matches is the only real operator in practice */
+        return this.toChildConditionDecl(options);
+    }
+    /**
+     * Gets the {@link ResourceJson.Json.ILooseConditionDecl | loose condition declaration} for this condition.
+     * @param options - The {@link ResourceJson.Helpers.IDeclarationOptions | options} to use when creating the loose
+     * condition declaration.
+     * @returns The {@link ResourceJson.Json.ILooseConditionDecl | loose condition declaration} for this condition.
+     * @public
+     */
+    toLooseConditionDecl(options) {
+        const showDefaults = (options === null || options === void 0 ? void 0 : options.showDefaults) === true;
+        return Object.assign(Object.assign(Object.assign({ qualifierName: this.qualifier.name, value: this.value }, (showDefaults || this.operator !== 'matches' ? { operator: this.operator } : {})), (showDefaults || this.priority !== this.qualifier.defaultPriority
+            ? { priority: this.priority }
+            : {})), (this.scoreAsDefault ? { scoreAsDefault: this.scoreAsDefault } : {}));
+    }
+    /**
+     * Converts this condition to a compiled condition representation.
+     * @param options - Optional compilation options controlling the output format.
+     * @returns A compiled condition object that can be used for serialization or runtime processing.
+     * @public
+     */
+    toCompiled(options) {
+        /* c8 ignore next 1 - defense in depth */
+        const operator = this.operator === 'matches' ? undefined : this.operator;
+        return Object.assign({ qualifierIndex: this.qualifier.index, operator, value: this.value, priority: this.priority, scoreAsDefault: this.scoreAsDefault }, ((options === null || options === void 0 ? void 0 : options.includeMetadata) === true ? { metadata: { key: this.key } } : {}));
+    }
+    /**
+     * Gets the {@link ConditionKey | condition key} for a supplied {@link Conditions.IValidatedConditionDecl | condition declaration}.
+     * @param decl - The {@link Conditions.IValidatedConditionDecl | condition declaration} for which to get the key.
+     * @returns `Success` with the condition key if successful, `Failure` otherwise.
+     * @public
+     */
+    static getKeyForDecl(decl) {
+        const scoreAsDefault = decl.scoreAsDefault ? `(${scoreFormatter.format(decl.scoreAsDefault)})` : '';
+        const key = decl.operator === 'matches'
+            ? `${decl.qualifier.name}-[${decl.value}]@${decl.priority}${scoreAsDefault}`
+            : `${decl.qualifier.name}-${decl.operator}-[${decl.value}]@${decl.priority}${scoreAsDefault}`;
+        return Validate.toConditionKey(key);
+    }
+}
+//# sourceMappingURL=condition.js.map

package/dist/packlets/conditions/conditionCollector.js

@@ -0,0 +1,69 @@
+/*
+ * 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 { captureResult, Collections, succeed, ValidatingCollector } from '@fgv/ts-utils';
+import { Condition } from './condition';
+import { Convert as CommonConvert } from '../common';
+import { validatedConditionDecl } from './convert';
+/**
+ * A `ValidatingCollector` for {@link Conditions.Condition | Conditions},
+ * which collects conditions supplied as either {@link Conditions.Condition | Condition} or
+ * {@link Conditions.IConditionDecl | IConditionDecl}.
+ * @public
+ */
+export class ConditionCollector extends ValidatingCollector {
+    /**
+     * Constructor for a {@link Conditions.ConditionCollector | ConditionCollector} object.
+     * @param params - Required {@link Conditions.IConditionCollectorCreateParams | parameters} for
+     * creating the collector.
+     */
+    constructor(params) {
+        var _a;
+        super({
+            converters: new Collections.KeyValueConverters({
+                key: CommonConvert.conditionKey,
+                value: (from) => this._toCondition(from)
+            })
+        });
+        this.qualifiers = params.qualifiers;
+        /* c8 ignore next 1 - ? is defense in depth */
+        (_a = params.conditions) === null || _a === void 0 ? void 0 : _a.forEach((c) => this.validating.add(c).orThrow());
+    }
+    /**
+     * Creates a new {@link Conditions.ConditionCollector | ConditionCollector} object.
+     * @param params - Required {@link Conditions.IConditionCollectorCreateParams | parameters} for
+     * creating the collector.
+     * @returns `Success` with the new collector if successful, or `Failure` with
+     * an error message if not.
+     */
+    static create(params) {
+        return captureResult(() => new ConditionCollector(params));
+    }
+    _toCondition(from) {
+        if (from instanceof Condition) {
+            return succeed(from);
+        }
+        return validatedConditionDecl
+            .convert(from, { qualifiers: this.qualifiers, conditionIndex: this.size })
+            .onSuccess((c) => Condition.create(c));
+    }
+}
+//# sourceMappingURL=conditionCollector.js.map

package/dist/packlets/conditions/conditionDecls.js

@@ -0,0 +1,23 @@
+/*
+ * 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 {};
+//# sourceMappingURL=conditionDecls.js.map