{"version":3,"sources":["../src/globals/Meteor.ts","../src/MeteorTypeValidation.ts","../node_modules/lodash-es/_freeGlobal.js","../node_modules/lodash-es/_root.js","../node_modules/lodash-es/_Symbol.js","../node_modules/lodash-es/_getRawTag.js","../node_modules/lodash-es/_objectToString.js","../node_modules/lodash-es/_baseGetTag.js","../node_modules/lodash-es/isObjectLike.js","../node_modules/lodash-es/isSymbol.js","../node_modules/lodash-es/_arrayMap.js","../node_modules/lodash-es/isArray.js","../node_modules/lodash-es/_baseToString.js","../node_modules/lodash-es/toString.js","../node_modules/lodash-es/_baseSlice.js","../node_modules/lodash-es/_castSlice.js","../node_modules/lodash-es/_hasUnicode.js","../node_modules/lodash-es/_asciiToArray.js","../node_modules/lodash-es/_unicodeToArray.js","../node_modules/lodash-es/_stringToArray.js","../node_modules/lodash-es/_createCaseFirst.js","../node_modules/lodash-es/upperFirst.js","../node_modules/lodash-es/_arrayReduce.js","../node_modules/lodash-es/_basePropertyOf.js","../node_modules/lodash-es/_deburrLetter.js","../node_modules/lodash-es/deburr.js","../node_modules/lodash-es/_asciiWords.js","../node_modules/lodash-es/_hasUnicodeWord.js","../node_modules/lodash-es/_unicodeWords.js","../node_modules/lodash-es/words.js","../node_modules/lodash-es/_createCompounder.js","../node_modules/lodash-es/startCase.js","../src/Errors.ts","../src/Logger.ts","../src/Definitions.ts","../src/Guard.ts"],"sourcesContent":["// Doing a little bit of a hack here so we won't have to depend on an Atmosphere package\nimport type { Meteor as _Meteor } from 'meteor/meteor';\nexport type { Subscription, DefinedMethods, DefinedPublications } from 'meteor/meteor';\ndeclare const Meteor: unknown;\nconst MeteorGlobal = Meteor as typeof _Meteor;\nexport { MeteorGlobal as Meteor };\n","/// <reference types=\"meteor/globals/ddp-rate-limiter\" />\nimport { Meteor } from '@meteor';\nimport { performance } from 'node:perf_hooks';\nimport type Pino from 'pino';\nimport { type GenericSchema, parse, ValiError } from 'valibot';\nimport { formatValibotError } from './Errors';\nimport type { GuardStatic } from './Guard';\nimport { Logger } from './Logger';\nimport type {\n    BaseContext,\n    ContextWrapper,\n    MethodDefinition,\n    MethodDefinitionMap,\n    PublicationDefinition,\n    PublicationDefinitionMap, RateLimiterRule,\n    ResourceType, UnwrapMethods, UnwrapPublications, UnwrapSchemaInput,\n    WrappedContext,\n} from './types/ValidatedResources';\n\nexport class MeteorTypeValidation<\n    TAddedContext = {},\n    TOptionsContext extends {\n        logger?: Pino.Logger;\n    } = {},\n    TExtendedContext extends TAddedContext & TOptionsContext = TAddedContext & TOptionsContext\n> {\n    constructor(protected readonly options: {\n        extendContext?: (context: ContextWrapper) => TExtendedContext;\n        createLogger?: (context: ContextWrapper) => TOptionsContext['logger'];\n        errorHandler?: (error: unknown) => never;\n    } = {}) {\n        this.setupDefaultLogger();\n    }\n    \n    protected setupDefaultLogger() {\n        if (this.options.createLogger) return;\n        if (this.options.createLogger === false) return;\n        \n        this.options.createLogger = ({ type, name, context }) => {\n            return  Logger.child({\n                [type]: { name },\n                user: { id: context.userId },\n            }, {\n                msgPrefix: `[${type}] [${name}] `,\n            });\n        }\n    }\n    \n    public defineMethods<\n        TSchemas extends Record<keyof TGuards, GenericSchema[]>,\n        TGuards extends Record<keyof TSchemas | keyof TResult, GuardStatic[]>,\n        TResult extends Record<keyof TSchemas | keyof TGuards, unknown>\n    >(methods: {\n        [key in keyof TSchemas | keyof TGuards | keyof TResult]: MethodDefinition<TSchemas[key], TGuards[key], TExtendedContext, TResult[key]>\n    }) {\n        return methods;\n    }\n    \n    public definePublications<\n        TSchemas extends Record<keyof TGuards, GenericSchema[]>,\n        TGuards extends Record<keyof TSchemas | keyof TResult, GuardStatic[]>,\n        TResult extends Record<keyof TSchemas | keyof TGuards, unknown>\n    >(publications: {\n        [key in keyof TSchemas | keyof TGuards | keyof TResult]: PublicationDefinition<TSchemas[key], TGuards[key], TExtendedContext, TResult[key]>\n    }) {\n        return publications;\n    }\n    \n    public exposeMethods<TMethods extends MethodDefinitionMap>(methods: TMethods): {\n        [key in keyof TMethods]: (...params: Parameters<TMethods[key]['method']>) => ReturnType<TMethods[key]['method']>\n    } {\n        const methodMap = Object.entries(methods).map(([name, definition]) => {\n            definition.rateLimiters?.forEach((rule) => this.loadRateLimit({ rule, name, type: 'method' }));\n            return [name, this.wrapResource({ definition, name })]\n        })\n        const wrappedMethods = Object.fromEntries(methodMap);\n        Meteor.methods(wrappedMethods);\n        return wrappedMethods;\n    }\n    \n    public exposePublications<TPublications extends PublicationDefinitionMap>(publications: TPublications): {\n        [key in keyof TPublications]: (...params: Parameters<TPublications[key]['publish']>) => ReturnType<TPublications[key]['publish']>\n    } {\n        const publicationMap = Object.entries(publications).map(([name, definition]) => {\n            const wrappedPublication = this.wrapResource({ name, definition });\n            Meteor.publish(name, wrappedPublication);\n            definition.rateLimiters?.forEach((rule) => this.loadRateLimit({ rule, name, type: 'publication' }));\n            return [name, wrappedPublication];\n        });\n        \n        return Object.fromEntries(publicationMap);\n    }\n    \n    protected loadRateLimit({ rule, type, name }: { rule: RateLimiterRule, type: ContextWrapper['type'], name: string }) {\n        DDPRateLimiter.addRule({\n            ...rule,\n            name,\n            type,\n        }, rule.requestCount ?? 10, rule.intervalMs ?? 1000);\n    }\n    \n    protected extendContext({ type, context, name }: ContextWrapper) {\n        const startTime = performance.now();\n        const logger = this.options.createLogger?.({ type, context, name });\n        const addedContext = this.options.extendContext?.({ type, context, name });\n        logger?.debug('Incoming request');\n        \n        Object.assign(context, {\n            type,\n            name,\n            logger,\n            startTime,\n        });\n        \n        if (!(addedContext instanceof Promise)) {\n            return Object.assign(context, addedContext);\n        }\n        \n        return addedContext.then((addedContext) => {\n            return Object.assign(context, addedContext)\n        })\n    }\n    \n    protected async validateRequest({ context, definition, params }: {\n        context: WrappedContext;\n        definition: MethodDefinition | PublicationDefinition,\n        params: unknown[]\n    }) {\n        // Run input validation on method arguments\n        const validatedParams = definition.schema.map((schema, index) => {\n            return parse(schema, params[index]);\n        });\n        \n        // Warn user if too many arguments were provided\n        if (params.length > validatedParams.length) {\n            throw new Meteor.Error(\n                'too_many_parameters',\n                `You're only allowed to supply ${definition.schema.length} parameters`,\n            );\n        }\n        \n        // Run guard validators\n        for (const guard of definition.guards) {\n            await new guard(context, validatedParams).validate();\n        }\n        \n        return {\n            validatedParams,\n        }\n    }\n    \n    protected withErrorHandler(method: (...params: unknown[]) => unknown): (...params: unknown[]) => any {\n        const customErrorHandler = this.options.errorHandler?.bind(this);\n        return async function(this: WrappedContext & TExtendedContext, ...params: unknown[]) {\n            try {\n                const result = await method.apply(this, params);\n                this.logger?.debug(`Request completed in ${(performance.now() - this.startTime).toLocaleString()}ms`);\n                return result;\n            } catch (error) {\n                if (customErrorHandler) {\n                    return customErrorHandler(error);\n                }\n                \n                let formattedError = error instanceof Error\n                                     ? error\n                                     : new Error(`Unexpected internal server error: ${error}`);\n                \n                if (error instanceof ValiError) {\n                    formattedError = formatValibotError(error);\n                }\n                \n                this.logger?.error({\n                    error: formattedError,\n                }, `Request failed: ${formattedError.message}`);\n                \n                throw formattedError;\n            }\n        };\n    }\n    \n    protected wrapResource({ definition, name }: {\n        definition: MethodDefinition | PublicationDefinition,\n        name: string,\n    }) {\n        const api = this;\n        const { run, type } = this.parseDefinition(definition);\n        \n        const handle = async function(this: BaseContext, ...params: unknown[]) {\n            const context = await api.extendContext({\n                type,\n                name,\n                context: this,\n            });\n            \n            const { validatedParams } = await api.validateRequest({\n                context,\n                definition,\n                params,\n            });\n            \n            return run.apply(context, validatedParams);\n        };\n        \n        return this.withErrorHandler(handle);\n    }\n    \n    private parseDefinition(definition: MethodDefinition | PublicationDefinition): {\n        type: ResourceType,\n        run: (...params: unknown[]) => unknown\n    } {\n        if ('publish' in definition) {\n            return {\n                type: 'publication',\n                run: definition.publish,\n            };\n        }\n        return {\n            type: 'method',\n            run: definition.method,\n        };\n    }\n}","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nexport default freeGlobal;\n","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nexport default root;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nexport default Symbol;\n","import Symbol from './_Symbol.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n  var isOwn = hasOwnProperty.call(value, symToStringTag),\n      tag = value[symToStringTag];\n\n  try {\n    value[symToStringTag] = undefined;\n    var unmasked = true;\n  } catch (e) {}\n\n  var result = nativeObjectToString.call(value);\n  if (unmasked) {\n    if (isOwn) {\n      value[symToStringTag] = tag;\n    } else {\n      delete value[symToStringTag];\n    }\n  }\n  return result;\n}\n\nexport default getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n  return nativeObjectToString.call(value);\n}\n\nexport default objectToString;\n","import Symbol from './_Symbol.js';\nimport getRawTag from './_getRawTag.js';\nimport objectToString from './_objectToString.js';\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n    undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n  if (value == null) {\n    return value === undefined ? undefinedTag : nullTag;\n  }\n  return (symToStringTag && symToStringTag in Object(value))\n    ? getRawTag(value)\n    : objectToString(value);\n}\n\nexport default baseGetTag;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return value != null && typeof value == 'object';\n}\n\nexport default isObjectLike;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nexport default isSymbol;\n","/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      result = Array(length);\n\n  while (++index < length) {\n    result[index] = iteratee(array[index], index, array);\n  }\n  return result;\n}\n\nexport default arrayMap;\n","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nexport default isArray;\n","import Symbol from './_Symbol.js';\nimport arrayMap from './_arrayMap.js';\nimport isArray from './isArray.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n  // Exit early for strings to avoid a performance hit in some environments.\n  if (typeof value == 'string') {\n    return value;\n  }\n  if (isArray(value)) {\n    // Recursively convert values (susceptible to call stack limits).\n    return arrayMap(value, baseToString) + '';\n  }\n  if (isSymbol(value)) {\n    return symbolToString ? symbolToString.call(value) : '';\n  }\n  var result = (value + '');\n  return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nexport default baseToString;\n","import baseToString from './_baseToString.js';\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n  return value == null ? '' : baseToString(value);\n}\n\nexport default toString;\n","/**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\nfunction baseSlice(array, start, end) {\n  var index = -1,\n      length = array.length;\n\n  if (start < 0) {\n    start = -start > length ? 0 : (length + start);\n  }\n  end = end > length ? length : end;\n  if (end < 0) {\n    end += length;\n  }\n  length = start > end ? 0 : ((end - start) >>> 0);\n  start >>>= 0;\n\n  var result = Array(length);\n  while (++index < length) {\n    result[index] = array[index + start];\n  }\n  return result;\n}\n\nexport default baseSlice;\n","import baseSlice from './_baseSlice.js';\n\n/**\n * Casts `array` to a slice if it's needed.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {number} start The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the cast slice.\n */\nfunction castSlice(array, start, end) {\n  var length = array.length;\n  end = end === undefined ? length : end;\n  return (!start && end >= length) ? array : baseSlice(array, start, end);\n}\n\nexport default castSlice;\n","/** Used to compose unicode character classes. */\nvar rsAstralRange = '\\\\ud800-\\\\udfff',\n    rsComboMarksRange = '\\\\u0300-\\\\u036f',\n    reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n    rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n    rsVarRange = '\\\\ufe0e\\\\ufe0f';\n\n/** Used to compose unicode capture groups. */\nvar rsZWJ = '\\\\u200d';\n\n/** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */\nvar reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange  + rsComboRange + rsVarRange + ']');\n\n/**\n * Checks if `string` contains Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n */\nfunction hasUnicode(string) {\n  return reHasUnicode.test(string);\n}\n\nexport default hasUnicode;\n","/**\n * Converts an ASCII `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction asciiToArray(string) {\n  return string.split('');\n}\n\nexport default asciiToArray;\n","/** Used to compose unicode character classes. */\nvar rsAstralRange = '\\\\ud800-\\\\udfff',\n    rsComboMarksRange = '\\\\u0300-\\\\u036f',\n    reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n    rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n    rsVarRange = '\\\\ufe0e\\\\ufe0f';\n\n/** Used to compose unicode capture groups. */\nvar rsAstral = '[' + rsAstralRange + ']',\n    rsCombo = '[' + rsComboRange + ']',\n    rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n    rsNonAstral = '[^' + rsAstralRange + ']',\n    rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n    rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n    rsZWJ = '\\\\u200d';\n\n/** Used to compose unicode regexes. */\nvar reOptMod = rsModifier + '?',\n    rsOptVar = '[' + rsVarRange + ']?',\n    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n    rsSeq = rsOptVar + reOptMod + rsOptJoin,\n    rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n/** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\nvar reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n/**\n * Converts a Unicode `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction unicodeToArray(string) {\n  return string.match(reUnicode) || [];\n}\n\nexport default unicodeToArray;\n","import asciiToArray from './_asciiToArray.js';\nimport hasUnicode from './_hasUnicode.js';\nimport unicodeToArray from './_unicodeToArray.js';\n\n/**\n * Converts `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\nfunction stringToArray(string) {\n  return hasUnicode(string)\n    ? unicodeToArray(string)\n    : asciiToArray(string);\n}\n\nexport default stringToArray;\n","import castSlice from './_castSlice.js';\nimport hasUnicode from './_hasUnicode.js';\nimport stringToArray from './_stringToArray.js';\nimport toString from './toString.js';\n\n/**\n * Creates a function like `_.lowerFirst`.\n *\n * @private\n * @param {string} methodName The name of the `String` case method to use.\n * @returns {Function} Returns the new case function.\n */\nfunction createCaseFirst(methodName) {\n  return function(string) {\n    string = toString(string);\n\n    var strSymbols = hasUnicode(string)\n      ? stringToArray(string)\n      : undefined;\n\n    var chr = strSymbols\n      ? strSymbols[0]\n      : string.charAt(0);\n\n    var trailing = strSymbols\n      ? castSlice(strSymbols, 1).join('')\n      : string.slice(1);\n\n    return chr[methodName]() + trailing;\n  };\n}\n\nexport default createCaseFirst;\n","import createCaseFirst from './_createCaseFirst.js';\n\n/**\n * Converts the first character of `string` to upper case.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.upperFirst('fred');\n * // => 'Fred'\n *\n * _.upperFirst('FRED');\n * // => 'FRED'\n */\nvar upperFirst = createCaseFirst('toUpperCase');\n\nexport default upperFirst;\n","/**\n * A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the first element of `array` as\n *  the initial value.\n * @returns {*} Returns the accumulated value.\n */\nfunction arrayReduce(array, iteratee, accumulator, initAccum) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  if (initAccum && length) {\n    accumulator = array[++index];\n  }\n  while (++index < length) {\n    accumulator = iteratee(accumulator, array[index], index, array);\n  }\n  return accumulator;\n}\n\nexport default arrayReduce;\n","/**\n * The base implementation of `_.propertyOf` without support for deep paths.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Function} Returns the new accessor function.\n */\nfunction basePropertyOf(object) {\n  return function(key) {\n    return object == null ? undefined : object[key];\n  };\n}\n\nexport default basePropertyOf;\n","import basePropertyOf from './_basePropertyOf.js';\n\n/** Used to map Latin Unicode letters to basic Latin letters. */\nvar deburredLetters = {\n  // Latin-1 Supplement block.\n  '\\xc0': 'A',  '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n  '\\xe0': 'a',  '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n  '\\xc7': 'C',  '\\xe7': 'c',\n  '\\xd0': 'D',  '\\xf0': 'd',\n  '\\xc8': 'E',  '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n  '\\xe8': 'e',  '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n  '\\xcc': 'I',  '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n  '\\xec': 'i',  '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n  '\\xd1': 'N',  '\\xf1': 'n',\n  '\\xd2': 'O',  '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n  '\\xf2': 'o',  '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n  '\\xd9': 'U',  '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n  '\\xf9': 'u',  '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n  '\\xdd': 'Y',  '\\xfd': 'y', '\\xff': 'y',\n  '\\xc6': 'Ae', '\\xe6': 'ae',\n  '\\xde': 'Th', '\\xfe': 'th',\n  '\\xdf': 'ss',\n  // Latin Extended-A block.\n  '\\u0100': 'A',  '\\u0102': 'A', '\\u0104': 'A',\n  '\\u0101': 'a',  '\\u0103': 'a', '\\u0105': 'a',\n  '\\u0106': 'C',  '\\u0108': 'C', '\\u010a': 'C', '\\u010c': 'C',\n  '\\u0107': 'c',  '\\u0109': 'c', '\\u010b': 'c', '\\u010d': 'c',\n  '\\u010e': 'D',  '\\u0110': 'D', '\\u010f': 'd', '\\u0111': 'd',\n  '\\u0112': 'E',  '\\u0114': 'E', '\\u0116': 'E', '\\u0118': 'E', '\\u011a': 'E',\n  '\\u0113': 'e',  '\\u0115': 'e', '\\u0117': 'e', '\\u0119': 'e', '\\u011b': 'e',\n  '\\u011c': 'G',  '\\u011e': 'G', '\\u0120': 'G', '\\u0122': 'G',\n  '\\u011d': 'g',  '\\u011f': 'g', '\\u0121': 'g', '\\u0123': 'g',\n  '\\u0124': 'H',  '\\u0126': 'H', '\\u0125': 'h', '\\u0127': 'h',\n  '\\u0128': 'I',  '\\u012a': 'I', '\\u012c': 'I', '\\u012e': 'I', '\\u0130': 'I',\n  '\\u0129': 'i',  '\\u012b': 'i', '\\u012d': 'i', '\\u012f': 'i', '\\u0131': 'i',\n  '\\u0134': 'J',  '\\u0135': 'j',\n  '\\u0136': 'K',  '\\u0137': 'k', '\\u0138': 'k',\n  '\\u0139': 'L',  '\\u013b': 'L', '\\u013d': 'L', '\\u013f': 'L', '\\u0141': 'L',\n  '\\u013a': 'l',  '\\u013c': 'l', '\\u013e': 'l', '\\u0140': 'l', '\\u0142': 'l',\n  '\\u0143': 'N',  '\\u0145': 'N', '\\u0147': 'N', '\\u014a': 'N',\n  '\\u0144': 'n',  '\\u0146': 'n', '\\u0148': 'n', '\\u014b': 'n',\n  '\\u014c': 'O',  '\\u014e': 'O', '\\u0150': 'O',\n  '\\u014d': 'o',  '\\u014f': 'o', '\\u0151': 'o',\n  '\\u0154': 'R',  '\\u0156': 'R', '\\u0158': 'R',\n  '\\u0155': 'r',  '\\u0157': 'r', '\\u0159': 'r',\n  '\\u015a': 'S',  '\\u015c': 'S', '\\u015e': 'S', '\\u0160': 'S',\n  '\\u015b': 's',  '\\u015d': 's', '\\u015f': 's', '\\u0161': 's',\n  '\\u0162': 'T',  '\\u0164': 'T', '\\u0166': 'T',\n  '\\u0163': 't',  '\\u0165': 't', '\\u0167': 't',\n  '\\u0168': 'U',  '\\u016a': 'U', '\\u016c': 'U', '\\u016e': 'U', '\\u0170': 'U', '\\u0172': 'U',\n  '\\u0169': 'u',  '\\u016b': 'u', '\\u016d': 'u', '\\u016f': 'u', '\\u0171': 'u', '\\u0173': 'u',\n  '\\u0174': 'W',  '\\u0175': 'w',\n  '\\u0176': 'Y',  '\\u0177': 'y', '\\u0178': 'Y',\n  '\\u0179': 'Z',  '\\u017b': 'Z', '\\u017d': 'Z',\n  '\\u017a': 'z',  '\\u017c': 'z', '\\u017e': 'z',\n  '\\u0132': 'IJ', '\\u0133': 'ij',\n  '\\u0152': 'Oe', '\\u0153': 'oe',\n  '\\u0149': \"'n\", '\\u017f': 's'\n};\n\n/**\n * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A\n * letters to basic Latin letters.\n *\n * @private\n * @param {string} letter The matched letter to deburr.\n * @returns {string} Returns the deburred letter.\n */\nvar deburrLetter = basePropertyOf(deburredLetters);\n\nexport default deburrLetter;\n","import deburrLetter from './_deburrLetter.js';\nimport toString from './toString.js';\n\n/** Used to match Latin Unicode letters (excluding mathematical operators). */\nvar reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n\n/** Used to compose unicode character classes. */\nvar rsComboMarksRange = '\\\\u0300-\\\\u036f',\n    reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n    rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;\n\n/** Used to compose unicode capture groups. */\nvar rsCombo = '[' + rsComboRange + ']';\n\n/**\n * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and\n * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).\n */\nvar reComboMark = RegExp(rsCombo, 'g');\n\n/**\n * Deburrs `string` by converting\n * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\n * letters to basic Latin letters and removing\n * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to deburr.\n * @returns {string} Returns the deburred string.\n * @example\n *\n * _.deburr('déjà vu');\n * // => 'deja vu'\n */\nfunction deburr(string) {\n  string = toString(string);\n  return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\n}\n\nexport default deburr;\n","/** Used to match words composed of alphanumeric characters. */\nvar reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n\n/**\n * Splits an ASCII `string` into an array of its words.\n *\n * @private\n * @param {string} The string to inspect.\n * @returns {Array} Returns the words of `string`.\n */\nfunction asciiWords(string) {\n  return string.match(reAsciiWord) || [];\n}\n\nexport default asciiWords;\n","/** Used to detect strings that need a more robust regexp to match words. */\nvar reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;\n\n/**\n * Checks if `string` contains a word composed of Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a word is found, else `false`.\n */\nfunction hasUnicodeWord(string) {\n  return reHasUnicodeWord.test(string);\n}\n\nexport default hasUnicodeWord;\n","/** Used to compose unicode character classes. */\nvar rsAstralRange = '\\\\ud800-\\\\udfff',\n    rsComboMarksRange = '\\\\u0300-\\\\u036f',\n    reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n    rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n    rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n    rsDingbatRange = '\\\\u2700-\\\\u27bf',\n    rsLowerRange = 'a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff',\n    rsMathOpRange = '\\\\xac\\\\xb1\\\\xd7\\\\xf7',\n    rsNonCharRange = '\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf',\n    rsPunctuationRange = '\\\\u2000-\\\\u206f',\n    rsSpaceRange = ' \\\\t\\\\x0b\\\\f\\\\xa0\\\\ufeff\\\\n\\\\r\\\\u2028\\\\u2029\\\\u1680\\\\u180e\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200a\\\\u202f\\\\u205f\\\\u3000',\n    rsUpperRange = 'A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde',\n    rsVarRange = '\\\\ufe0e\\\\ufe0f',\n    rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n\n/** Used to compose unicode capture groups. */\nvar rsApos = \"['\\u2019]\",\n    rsBreak = '[' + rsBreakRange + ']',\n    rsCombo = '[' + rsComboRange + ']',\n    rsDigits = '\\\\d+',\n    rsDingbat = '[' + rsDingbatRange + ']',\n    rsLower = '[' + rsLowerRange + ']',\n    rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',\n    rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n    rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n    rsNonAstral = '[^' + rsAstralRange + ']',\n    rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n    rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n    rsUpper = '[' + rsUpperRange + ']',\n    rsZWJ = '\\\\u200d';\n\n/** Used to compose unicode regexes. */\nvar rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',\n    rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',\n    rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',\n    rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',\n    reOptMod = rsModifier + '?',\n    rsOptVar = '[' + rsVarRange + ']?',\n    rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n    rsOrdLower = '\\\\d*(?:1st|2nd|3rd|(?![123])\\\\dth)(?=\\\\b|[A-Z_])',\n    rsOrdUpper = '\\\\d*(?:1ST|2ND|3RD|(?![123])\\\\dTH)(?=\\\\b|[a-z_])',\n    rsSeq = rsOptVar + reOptMod + rsOptJoin,\n    rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq;\n\n/** Used to match complex or compound words. */\nvar reUnicodeWord = RegExp([\n  rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',\n  rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',\n  rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,\n  rsUpper + '+' + rsOptContrUpper,\n  rsOrdUpper,\n  rsOrdLower,\n  rsDigits,\n  rsEmoji\n].join('|'), 'g');\n\n/**\n * Splits a Unicode `string` into an array of its words.\n *\n * @private\n * @param {string} The string to inspect.\n * @returns {Array} Returns the words of `string`.\n */\nfunction unicodeWords(string) {\n  return string.match(reUnicodeWord) || [];\n}\n\nexport default unicodeWords;\n","import asciiWords from './_asciiWords.js';\nimport hasUnicodeWord from './_hasUnicodeWord.js';\nimport toString from './toString.js';\nimport unicodeWords from './_unicodeWords.js';\n\n/**\n * Splits `string` into an array of its words.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to inspect.\n * @param {RegExp|string} [pattern] The pattern to match words.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the words of `string`.\n * @example\n *\n * _.words('fred, barney, & pebbles');\n * // => ['fred', 'barney', 'pebbles']\n *\n * _.words('fred, barney, & pebbles', /[^, ]+/g);\n * // => ['fred', 'barney', '&', 'pebbles']\n */\nfunction words(string, pattern, guard) {\n  string = toString(string);\n  pattern = guard ? undefined : pattern;\n\n  if (pattern === undefined) {\n    return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n  }\n  return string.match(pattern) || [];\n}\n\nexport default words;\n","import arrayReduce from './_arrayReduce.js';\nimport deburr from './deburr.js';\nimport words from './words.js';\n\n/** Used to compose unicode capture groups. */\nvar rsApos = \"['\\u2019]\";\n\n/** Used to match apostrophes. */\nvar reApos = RegExp(rsApos, 'g');\n\n/**\n * Creates a function like `_.camelCase`.\n *\n * @private\n * @param {Function} callback The function to combine each word.\n * @returns {Function} Returns the new compounder function.\n */\nfunction createCompounder(callback) {\n  return function(string) {\n    return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');\n  };\n}\n\nexport default createCompounder;\n","import createCompounder from './_createCompounder.js';\nimport upperFirst from './upperFirst.js';\n\n/**\n * Converts `string` to\n * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\n *\n * @static\n * @memberOf _\n * @since 3.1.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the start cased string.\n * @example\n *\n * _.startCase('--foo-bar--');\n * // => 'Foo Bar'\n *\n * _.startCase('fooBar');\n * // => 'Foo Bar'\n *\n * _.startCase('__FOO_BAR__');\n * // => 'FOO BAR'\n */\nvar startCase = createCompounder(function(result, word, index) {\n  return result + (index ? ' ' : '') + upperFirst(word);\n});\n\nexport default startCase;\n","import { Meteor } from '@meteor';\nimport { startCase } from 'lodash-es';\nimport { flatten, type UnknownSchema, ValiError } from 'valibot';\n\nexport function formatValibotError(error: ValiError<UnknownSchema>) {\n    const errors: { message: string, reason?: string, key: string }[] = [];\n    const { nested, root } = flatten<never>(error.issues) as { nested: Record<string, string[]>, root: string[] };\n    \n    Object.entries(nested).forEach(([key, messages]) => {\n        messages?.forEach((message) => {\n            errors.push({\n                message: message.replace('Invalid type: Expected', `Expected ${startCase(key)} to be`),\n                reason: message,\n                key,\n            })\n        })\n    });\n    \n    root?.forEach((message) => {\n        errors.push({\n            message,\n            key: '[root]'\n        })\n    });\n    return new MeteorError('ValiError', error.message, { errors, issues: error.issues });\n}\n\nclass MeteorError extends Meteor.Error {\n    constructor(code: string | number, message: string, details: string | object) {\n        super(\n            code,\n            message,\n            // @ts-expect-error @types/meteor invalidly sets a 'string' type here.\n            details\n        );\n    }\n}","import { pino } from 'pino';\nexport const Logger = pino({})","import { MeteorTypeValidation } from './MeteorTypeValidation';\n\n/**\n * Base API instance - has default contexts and nothing fancy.\n * This class can be extended to add additional context into\n * methods and publications' `this` type.\n */\nconst defaultApi = new MeteorTypeValidation();\n\n/**\n * Defines a type safe method with input and context validation.\n * The result of this function should be exported so that we can infer all its types globally.\n *\n * @example /imports/api/topics/methods.ts\n * export default defineMethods({\n *     'topic.create': {\n *         schema: [TopicSchemas.create],\n *         guards: [...],\n *         method(topic) {\n *             ...\n *         }\n *     }\n * })\n *\n * @example ./server/methods.ts\n * import TopicMethods from '/imports/api/topics/methods'\n *\n * const AllMethods = {\n *     ...TopicMethods,\n *     // ... all other methods\n * }\n *\n * Meteor.startup(() => {\n *     exposeMethods(AllMethods)\n * })\n *\n * declare module 'meteor/meteor' {\n *     interface DefinedMethods extends UnwrapMethods<typeof AllMethods> {}\n * }\n */\nexport const defineMethods = defaultApi.defineMethods.bind(defaultApi);\n\n/**\n * Defines a type safe publication input and context validation.\n * The result of this method should be exported so that we can infer all its types globally.\n */\nexport const definePublications = defaultApi.definePublications.bind(defaultApi);\n\nexport const exposeMethods = defaultApi.exposeMethods.bind(defaultApi);\nexport const exposePublications = defaultApi.exposePublications.bind(defaultApi);","import type { GenericSchema } from 'valibot';\nimport type { BaseContext, UnwrapSchemaOutput } from './types/ValidatedResources';\n\nexport abstract class Guard {\n    constructor(\n        public readonly context: BaseContext,\n        protected readonly params: unknown[]\n    ) {}\n    public abstract validate(): asserts this;\n    public abstract get validatedContext(): unknown;\n}\n\nexport interface GuardStatic<TGuard extends Guard = Guard> {\n    new(...context: any): TGuard;\n}\n\nexport type GuardFunction<\n    TSchemas extends GenericSchema[] = GenericSchema[],\n> = (request: {\n    context: BaseContext,\n    params: UnwrapSchemaOutput<TSchemas>\n}) => asserts request;"],"mappings":"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UAAU;AAAA,EAAK,UAAU;AAAA,EACvE,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EACvE,UAAU;AAAA,EAAM,UAAU;AAAA,EAC1B,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EACzC,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EACvE,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EACvE,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EACxD,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EACxD,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EACzC,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EACzC,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EACzC,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EACzC,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EACxD,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EACxD,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EACzC,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EACzC,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EACtF,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EAAK,UAAU;AAAA,EACtF,UAAU;AAAA,EAAM,UAAU;AAAA,EAC1B,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EACzC,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EACzC,UAAU;AAAA,EAAM,UAAU;AAAA,EAAK,UAAU;AAAA,EACzC,UAAU;AAAA,EAAM,UAAU;AAAA,EAC1B,UAAU;AAAA,EAAM,UAAU;AAAA,EAC1B,UAAU;AAAA,EAAM,UAAU;AAC5B;AAUA,IAAI,eAAe,uBAAe,eAAe;AAEjD,IAAO,uBAAQ;;;AClEf,IAAI,UAAU;AAGd,IAAIC,qBAAoB;AAAxB,IACIC,yBAAwB;AAD5B,IAEIC,uBAAsB;AAF1B,IAGIC,gBAAeH,qBAAoBC,yBAAwBC;AAG/D,IAAIE,WAAU,MAAMD,gBAAe;AAMnC,IAAI,cAAc,OAAOC,UAAS,GAAG;AAoBrC,SAAS,OAAO,QAAQ;AACtB,WAAS,iBAAS,MAAM;AACxB,SAAO,UAAU,OAAO,QAAQ,SAAS,oBAAY,EAAE,QAAQ,aAAa,EAAE;AAChF;AAEA,IAAO,iBAAQ;;;AC3Cf,IAAI,cAAc;AASlB,SAAS,WAAW,QAAQ;AAC1B,SAAO,OAAO,MAAM,WAAW,KAAK,CAAC;AACvC;AAEA,IAAO,qBAAQ;;;ACbf,IAAI,mBAAmB;AASvB,SAAS,eAAe,QAAQ;AAC9B,SAAO,iBAAiB,KAAK,MAAM;AACrC;AAEA,IAAO,yBAAQ;;;ACbf,IAAIC,iBAAgB;AAApB,IACIC,qBAAoB;AADxB,IAEIC,yBAAwB;AAF5B,IAGIC,uBAAsB;AAH1B,IAIIC,gBAAeH,qBAAoBC,yBAAwBC;AAJ/D,IAKI,iBAAiB;AALrB,IAMI,eAAe;AANnB,IAOI,gBAAgB;AAPpB,IAQI,iBAAiB;AARrB,IASI,qBAAqB;AATzB,IAUI,eAAe;AAVnB,IAWI,eAAe;AAXnB,IAYIE,cAAa;AAZjB,IAaI,eAAe,gBAAgB,iBAAiB,qBAAqB;AAGzE,IAAI,SAAS;AAAb,IACI,UAAU,MAAM,eAAe;AADnC,IAEIC,WAAU,MAAMF,gBAAe;AAFnC,IAGI,WAAW;AAHf,IAII,YAAY,MAAM,iBAAiB;AAJvC,IAKI,UAAU,MAAM,eAAe;AALnC,IAMI,SAAS,OAAOJ,iBAAgB,eAAe,WAAW,iBAAiB,eAAe,eAAe;AAN7G,IAOIO,UAAS;AAPb,IAQIC,cAAa,QAAQF,WAAU,MAAMC,UAAS;AARlD,IASIE,eAAc,OAAOT,iBAAgB;AATzC,IAUIU,cAAa;AAVjB,IAWIC,cAAa;AAXjB,IAYI,UAAU,MAAM,eAAe;AAZnC,IAaIC,SAAQ;AAGZ,IAAI,cAAc,QAAQ,UAAU,MAAM,SAAS;AAAnD,IACI,cAAc,QAAQ,UAAU,MAAM,SAAS;AADnD,IAEI,kBAAkB,QAAQ,SAAS;AAFvC,IAGI,kBAAkB,QAAQ,SAAS;AAHvC,IAIIC,YAAWL,cAAa;AAJ5B,IAKIM,YAAW,MAAMT,cAAa;AALlC,IAMIU,aAAY,QAAQH,SAAQ,QAAQ,CAACH,cAAaC,aAAYC,WAAU,EAAE,KAAK,GAAG,IAAI,MAAMG,YAAWD,YAAW;AANtH,IAOI,aAAa;AAPjB,IAQI,aAAa;AARjB,IASIG,SAAQF,YAAWD,YAAWE;AATlC,IAUI,UAAU,QAAQ,CAAC,WAAWL,aAAYC,WAAU,EAAE,KAAK,GAAG,IAAI,MAAMK;AAG5E,IAAI,gBAAgB,OAAO;AAAA,EACzB,UAAU,MAAM,UAAU,MAAM,kBAAkB,QAAQ,CAAC,SAAS,SAAS,GAAG,EAAE,KAAK,GAAG,IAAI;AAAA,EAC9F,cAAc,MAAM,kBAAkB,QAAQ,CAAC,SAAS,UAAU,aAAa,GAAG,EAAE,KAAK,GAAG,IAAI;AAAA,EAChG,UAAU,MAAM,cAAc,MAAM;AAAA,EACpC,UAAU,MAAM;AAAA,EAChB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAK,GAAG,GAAG,GAAG;AAShB,SAAS,aAAa,QAAQ;AAC5B,SAAO,OAAO,MAAM,aAAa,KAAK,CAAC;AACzC;AAEA,IAAO,uBAAQ;;;AC5Cf,SAAS,MAAM,QAAQ,SAAS,OAAO;AACrC,WAAS,iBAAS,MAAM;AACxB,YAAU,QAAQ,SAAY;AAE9B,MAAI,YAAY,QAAW;AACzB,WAAO,uBAAe,MAAM,IAAI,qBAAa,MAAM,IAAI,mBAAW,MAAM;AAAA,EAC1E;AACA,SAAO,OAAO,MAAM,OAAO,KAAK,CAAC;AACnC;AAEA,IAAO,gBAAQ;;;AC7Bf,IAAIC,UAAS;AAGb,IAAI,SAAS,OAAOA,SAAQ,GAAG;AAS/B,SAAS,iBAAiB,UAAU;AAClC,SAAO,SAAS,QAAQ;AACtB,WAAO,oBAAY,cAAM,eAAO,MAAM,EAAE,QAAQ,QAAQ,EAAE,CAAC,GAAG,UAAU,EAAE;AAAA,EAC5E;AACF;AAEA,IAAO,2BAAQ;;;ACCf,IAAI,YAAY,yBAAiB,SAAS,QAAQ,MAAM,OAAO;AAC7D,SAAO,UAAU,QAAQ,MAAM,MAAM,mBAAW,IAAI;AACtD,CAAC;AAED,IAAO,oBAAQ;;;AC1Bf,SAAS,eAA8C;AAEhD,SAAS,mBAAmB,OAAiC;AAChE,QAAM,SAA8D,CAAC;AACrE,QAAM,EAAE,QAAQ,MAAAC,MAAK,IAAI,QAAe,MAAM,MAAM;AAEpD,SAAO,QAAQ,MAAM,EAAE,QAAQ,CAAC,CAAC,KAAK,QAAQ,MAAM;AAChD,cAAU,QAAQ,CAAC,YAAY;AAC3B,aAAO,KAAK;AAAA,QACR,SAAS,QAAQ,QAAQ,0BAA0B,YAAY,kBAAU,GAAG,CAAC,QAAQ;AAAA,QACrF,QAAQ;AAAA,QACR;AAAA,MACJ,CAAC;AAAA,IACL,CAAC;AAAA,EACL,CAAC;AAED,EAAAA,OAAM,QAAQ,CAAC,YAAY;AACvB,WAAO,KAAK;AAAA,MACR;AAAA,MACA,KAAK;AAAA,IACT,CAAC;AAAA,EACL,CAAC;AACD,SAAO,IAAI,YAAY,aAAa,MAAM,SAAS,EAAE,QAAQ,QAAQ,MAAM,OAAO,CAAC;AACvF;AAEA,IAAM,cAAN,cAA0B,aAAO,MAAM;AAAA,EACnC,YAAY,MAAuB,SAAiB,SAA0B;AAC1E;AAAA,MACI;AAAA,MACA;AAAA;AAAA,MAEA;AAAA,IACJ;AAAA,EACJ;AACJ;;;ACpCA,SAAS,YAAY;AACd,IAAM,SAAS,KAAK,CAAC,CAAC;;;AhCkBtB,IAAM,uBAAN,MAML;AAAA,EACE,YAA+B,UAI3B,CAAC,GAAG;AAJuB;AAK3B,SAAK,mBAAmB;AAAA,EAC5B;AAAA,EAEU,qBAAqB;AAC3B,QAAI,KAAK,QAAQ;AAAc;AAC/B,QAAI,KAAK,QAAQ,iBAAiB;AAAO;AAEzC,SAAK,QAAQ,eAAe,CAAC,EAAE,MAAM,MAAM,QAAQ,MAAM;AACrD,aAAQ,OAAO,MAAM;AAAA,QACjB,CAAC,IAAI,GAAG,EAAE,KAAK;AAAA,QACf,MAAM,EAAE,IAAI,QAAQ,OAAO;AAAA,MAC/B,GAAG;AAAA,QACC,WAAW,IAAI,IAAI,MAAM,IAAI;AAAA,MACjC,CAAC;AAAA,IACL;AAAA,EACJ;AAAA,EAEO,cAIL,SAEC;AACC,WAAO;AAAA,EACX;AAAA,EAEO,mBAIL,cAEC;AACC,WAAO;AAAA,EACX;AAAA,EAEO,cAAoD,SAEzD;AACE,UAAM,YAAY,OAAO,QAAQ,OAAO,EAAE,IAAI,CAAC,CAAC,MAAM,UAAU,MAAM;AAClE,iBAAW,cAAc,QAAQ,CAAC,SAAS,KAAK,cAAc,EAAE,MAAM,MAAM,MAAM,SAAS,CAAC,CAAC;AAC7F,aAAO,CAAC,MAAM,KAAK,aAAa,EAAE,YAAY,KAAK,CAAC,CAAC;AAAA,IACzD,CAAC;AACD,UAAM,iBAAiB,OAAO,YAAY,SAAS;AACnD,iBAAO,QAAQ,cAAc;AAC7B,WAAO;AAAA,EACX;AAAA,EAEO,mBAAmE,cAExE;AACE,UAAM,iBAAiB,OAAO,QAAQ,YAAY,EAAE,IAAI,CAAC,CAAC,MAAM,UAAU,MAAM;AAC5E,YAAM,qBAAqB,KAAK,aAAa,EAAE,MAAM,WAAW,CAAC;AACjE,mBAAO,QAAQ,MAAM,kBAAkB;AACvC,iBAAW,cAAc,QAAQ,CAAC,SAAS,KAAK,cAAc,EAAE,MAAM,MAAM,MAAM,cAAc,CAAC,CAAC;AAClG,aAAO,CAAC,MAAM,kBAAkB;AAAA,IACpC,CAAC;AAED,WAAO,OAAO,YAAY,cAAc;AAAA,EAC5C;AAAA,EAEU,cAAc,EAAE,MAAM,MAAM,KAAK,GAA0E;AACjH,mBAAe,QAAQ;AAAA,MACnB,GAAG;AAAA,MACH;AAAA,MACA;AAAA,IACJ,GAAG,KAAK,gBAAgB,IAAI,KAAK,cAAc,GAAI;AAAA,EACvD;AAAA,EAEU,cAAc,EAAE,MAAM,SAAS,KAAK,GAAmB;AAC7D,UAAM,YAAY,YAAY,IAAI;AAClC,UAAM,SAAS,KAAK,QAAQ,eAAe,EAAE,MAAM,SAAS,KAAK,CAAC;AAClE,UAAM,eAAe,KAAK,QAAQ,gBAAgB,EAAE,MAAM,SAAS,KAAK,CAAC;AACzE,YAAQ,MAAM,kBAAkB;AAEhC,WAAO,OAAO,SAAS;AAAA,MACnB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACJ,CAAC;AAED,QAAI,EAAE,wBAAwB,UAAU;AACpC,aAAO,OAAO,OAAO,SAAS,YAAY;AAAA,IAC9C;AAEA,WAAO,aAAa,KAAK,CAACC,kBAAiB;AACvC,aAAO,OAAO,OAAO,SAASA,aAAY;AAAA,IAC9C,CAAC;AAAA,EACL;AAAA,EAEA,MAAgB,gBAAgB,EAAE,SAAS,YAAY,OAAO,GAI3D;AAEC,UAAM,kBAAkB,WAAW,OAAO,IAAI,CAAC,QAAQ,UAAU;AAC7D,aAAO,MAAM,QAAQ,OAAO,KAAK,CAAC;AAAA,IACtC,CAAC;AAGD,QAAI,OAAO,SAAS,gBAAgB,QAAQ;AACxC,YAAM,IAAI,aAAO;AAAA,QACb;AAAA,QACA,iCAAiC,WAAW,OAAO,MAAM;AAAA,MAC7D;AAAA,IACJ;AAGA,eAAW,SAAS,WAAW,QAAQ;AACnC,YAAM,IAAI,MAAM,SAAS,eAAe,EAAE,SAAS;AAAA,IACvD;AAEA,WAAO;AAAA,MACH;AAAA,IACJ;AAAA,EACJ;AAAA,EAEU,iBAAiB,QAA0E;AACjG,UAAM,qBAAqB,KAAK,QAAQ,cAAc,KAAK,IAAI;AAC/D,WAAO,kBAA2D,QAAmB;AACjF,UAAI;AACA,cAAM,SAAS,MAAM,OAAO,MAAM,MAAM,MAAM;AAC9C,aAAK,QAAQ,MAAM,yBAAyB,YAAY,IAAI,IAAI,KAAK,WAAW,eAAe,CAAC,IAAI;AACpG,eAAO;AAAA,MACX,SAAS,OAAO;AACZ,YAAI,oBAAoB;AACpB,iBAAO,mBAAmB,KAAK;AAAA,QACnC;AAEA,YAAI,iBAAiB,iBAAiB,QACf,QACA,IAAI,MAAM,qCAAqC,KAAK,EAAE;AAE7E,YAAI,iBAAiBC,YAAW;AAC5B,2BAAiB,mBAAmB,KAAK;AAAA,QAC7C;AAEA,aAAK,QAAQ,MAAM;AAAA,UACf,OAAO;AAAA,QACX,GAAG,mBAAmB,eAAe,OAAO,EAAE;AAE9C,cAAM;AAAA,MACV;AAAA,IACJ;AAAA,EACJ;AAAA,EAEU,aAAa,EAAE,YAAY,KAAK,GAGvC;AACC,UAAM,MAAM;AACZ,UAAM,EAAE,KAAK,KAAK,IAAI,KAAK,gBAAgB,UAAU;AAErD,UAAM,SAAS,kBAAqC,QAAmB;AACnE,YAAM,UAAU,MAAM,IAAI,cAAc;AAAA,QACpC;AAAA,QACA;AAAA,QACA,SAAS;AAAA,MACb,CAAC;AAED,YAAM,EAAE,gBAAgB,IAAI,MAAM,IAAI,gBAAgB;AAAA,QAClD;AAAA,QACA;AAAA,QACA;AAAA,MACJ,CAAC;AAED,aAAO,IAAI,MAAM,SAAS,eAAe;AAAA,IAC7C;AAEA,WAAO,KAAK,iBAAiB,MAAM;AAAA,EACvC;AAAA,EAEQ,gBAAgB,YAGtB;AACE,QAAI,aAAa,YAAY;AACzB,aAAO;AAAA,QACH,MAAM;AAAA,QACN,KAAK,WAAW;AAAA,MACpB;AAAA,IACJ;AACA,WAAO;AAAA,MACH,MAAM;AAAA,MACN,KAAK,WAAW;AAAA,IACpB;AAAA,EACJ;AACJ;;;AiCtNA,IAAM,aAAa,IAAI,qBAAqB;AAiCrC,IAAM,gBAAgB,WAAW,cAAc,KAAK,UAAU;AAM9D,IAAM,qBAAqB,WAAW,mBAAmB,KAAK,UAAU;AAExE,IAAM,gBAAgB,WAAW,cAAc,KAAK,UAAU;AAC9D,IAAM,qBAAqB,WAAW,mBAAmB,KAAK,UAAU;;;AC9CxE,IAAe,QAAf,MAAqB;AAAA,EACxB,YACoB,SACG,QACrB;AAFkB;AACG;AAAA,EACpB;AAGP;","names":["ValiError","objectProto","nativeObjectToString","symToStringTag","rsAstralRange","rsComboMarksRange","reComboHalfMarksRange","rsComboSymbolsRange","rsComboRange","rsVarRange","rsZWJ","rsComboMarksRange","reComboHalfMarksRange","rsComboSymbolsRange","rsComboRange","rsCombo","rsAstralRange","rsComboMarksRange","reComboHalfMarksRange","rsComboSymbolsRange","rsComboRange","rsVarRange","rsCombo","rsFitz","rsModifier","rsNonAstral","rsRegional","rsSurrPair","rsZWJ","reOptMod","rsOptVar","rsOptJoin","rsSeq","rsApos","root","addedContext","ValiError"]}