{"version":3,"file":"predicates-NOnUyMic.mjs","names":[],"sources":["../src/utils/combine/combine.util.ts","../src/predicates/and/and.predicate.ts","../src/predicates/is-context/is-context.predicate.ts","../src/predicates/is-multi/is-multi.predicate.ts","../src/utils/get-paginate/get-paginate.util.ts","../src/predicates/is-paginated/is-paginated.predicate.ts","../src/predicates/is-provider/is-provider.predicate.ts","../src/predicates/not/not.predicate.ts","../src/predicates/or/or.predicate.ts","../src/predicates/should-skip/should-skip.predicate.ts","../src/hooks/iff-else/iff-else.hook.ts","../src/hooks/iff/iff.hook.ts","../src/hooks/skippable/skippable.hook.ts","../src/hooks/throw-if/throw-if.hook.ts","../src/hooks/unless/unless.hook.ts"],"sourcesContent":["import type { HookContext } from '@feathersjs/feathers'\nimport type { HookFunction } from '../../types.js'\nimport { isPromise } from '../../common/index.js'\n\n/**\n * Sequentially executes multiple hooks, passing the updated context from one to the next.\n * Returns a single hook function that runs the entire chain. If any hook throws,\n * the error is annotated with the current hook context.\n *\n * @example\n * ```ts\n * import { combine } from 'feathers-utils/hooks'\n *\n * const combinedHook = combine(hookA(), hookB(), hookC())\n * app.service('users').hooks({ before: { create: [combinedHook] } })\n * ```\n *\n * @see https://utils.feathersjs.com/utils/combine.html\n */\nexport function combine<H extends HookContext = HookContext>(\n  ...serviceHooks: HookFunction<H>[]\n) {\n  const isContext = function (ctx: H) {\n    return typeof ctx?.method === 'string' && typeof ctx?.type === 'string'\n  }\n\n  return async function (context: H) {\n    let ctx = context\n\n    const updateCurrentHook = (current: void | H) => {\n      // Either use the returned hook object or the current\n      // hook object from the chain if the hook returned undefined\n      if (current) {\n        if (!isContext(current)) {\n          throw new Error(\n            `${ctx.type} hook for '${ctx.method}' method returned invalid hook object`,\n          )\n        }\n\n        ctx = current\n      }\n\n      return ctx\n    }\n\n    // Run the hooks sequentially, only awaiting when a hook is actually async.\n    // Avoids a microtask hop per hook and a per-hook `bind` allocation.\n    try {\n      for (const fn of serviceHooks) {\n        // @ts-expect-error `this` is the bound service-hook context\n        const currentCtx = fn.call(this, ctx)\n        updateCurrentHook(isPromise(currentCtx) ? await currentCtx : currentCtx)\n      }\n      return ctx\n    } catch (error: any) {\n      // Add the hook information to any errors\n      error.hook = ctx\n      throw error\n    }\n  }\n}\n","import type { HookContext } from '@feathersjs/feathers'\nimport type { PredicateFn } from '../../types.js'\nimport { isPromise } from '../../common/index.js'\n\n/**\n * Returns a predicate that is `true` only when **all** given predicates are `true` (logical AND).\n * Supports both sync and async predicates. Short-circuits on the first `false` result.\n * Undefined predicates in the list are skipped.\n *\n * @example\n * ```ts\n * import { iff, and, isProvider, isMulti } from 'feathers-utils/predicates'\n *\n * app.service('users').hooks({\n *   before: { all: [iff(and(isProvider('external'), isMulti), checkMulti())] }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/predicates/and.html\n */\nexport const and = <H extends HookContext = HookContext>(\n  ...predicates: (PredicateFn<H> | undefined)[]\n): PredicateFn<H> => {\n  const filtered = predicates.filter(\n    (p): p is PredicateFn<H> => p !== undefined,\n  )\n\n  return (context: H): boolean | Promise<boolean> => {\n    // The identity element of logical AND is `true` (an empty AND is true).\n    if (!filtered.length) {\n      return true\n    }\n\n    const promises: Promise<boolean>[] = []\n\n    for (const predicate of filtered) {\n      const result = predicate(context)\n      if (isPromise(result)) {\n        promises.push(result)\n      } else if (!result) {\n        // any falsy sync result short-circuits to false\n        return false\n      }\n    }\n\n    if (!promises.length) {\n      return true\n    }\n\n    return Promise.all(promises).then((results) =>\n      results.every((result) => !!result),\n    )\n  }\n}\n\n// Alias for 'every'\nexport const every = and\n","import type { HookContext } from '@feathersjs/feathers'\nimport type { MaybeArray } from '../../internal.utils.js'\nimport { toArray } from '../../internal.utils.js'\n\nexport type IsContextOptions<H extends HookContext = HookContext> = {\n  path?: MaybeArray<H['path']>\n  type?: MaybeArray<H['type']>\n  method?: MaybeArray<H['method']>\n}\n\n/**\n * Returns a predicate that checks whether the hook context matches the given criteria.\n * You can filter by `path` (service name), `type` (before/after/around/error),\n * and/or `method` (find/get/create/update/patch/remove).\n *\n * @example\n * ```ts\n * import { iff, isContext } from 'feathers-utils/predicates'\n *\n * app.service('users').hooks({\n *   before: { all: [iff(isContext({ method: 'create', type: 'before' }), validateHook())] }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/predicates/is-context.html\n */\nexport const isContext = <H extends HookContext = HookContext>(\n  options: IsContextOptions<H>,\n) => {\n  const path = options.path != null ? toArray(options.path) : undefined\n  const type = options.type != null ? toArray(options.type) : undefined\n  const method = options.method != null ? toArray(options.method) : undefined\n\n  return (context: any): boolean => {\n    if (path && !path.some((x) => context.path === x)) {\n      return false\n    }\n\n    if (type && !type.some((x) => context.type === x)) {\n      return false\n    }\n\n    if (method && !method.some((x) => context.method === x)) {\n      return false\n    }\n\n    return true\n  }\n}\n","import type { HookContext } from '@feathersjs/feathers'\n\n/**\n * Checks if the current hook context represents a multi operation.\n * Returns `true` for `find`, for `create` with array data, and for `patch`/`remove`\n * with `id === null`. Returns `false` for `get` and `update`.\n *\n * @example\n * ```ts\n * import { iff, isMulti } from 'feathers-utils/predicates'\n *\n * app.service('users').hooks({\n *   before: { all: [iff(isMulti, rateLimitHook())] }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/predicates/is-multi.html\n */\nexport const isMulti = <H extends HookContext = HookContext>(\n  context: H,\n): boolean => {\n  const { method } = context\n  if (method === 'find') {\n    return true\n  } else if (method === 'patch' || method === 'remove') {\n    return context.id == null\n  } else if (method === 'create') {\n    return Array.isArray(context.data)\n  } else if (method === 'get' || method === 'update') {\n    return false\n  }\n\n  return false\n}\n","import type { PaginationOptions } from '@feathersjs/adapter-commons'\nimport type { HookContext } from '@feathersjs/feathers'\nimport { hasOwnProperty } from '../../internal.utils.js'\n\n/**\n * Resolves the active pagination options for the current hook context.\n * Checks (in order): `context.params.paginate`, `service.options.paginate`,\n * and `context.params.adapter.paginate`. Returns `undefined` if pagination is disabled.\n *\n * @example\n * ```ts\n * import { getPaginate } from 'feathers-utils/utils'\n *\n * const paginate = getPaginate(context)\n * if (paginate) {\n *   console.log('Max items:', paginate.max)\n * }\n * ```\n *\n * @see https://utils.feathersjs.com/utils/get-paginate.html\n */\nexport const getPaginate = <H extends HookContext = HookContext>(\n  context: H,\n): PaginationOptions | undefined => {\n  if (hasOwnProperty(context.params, 'paginate')) {\n    // covers `paginate: false` too (`false || undefined` -> undefined)\n    return (context.params.paginate as PaginationOptions) || undefined\n  }\n\n  let options = context.service?.options || {}\n\n  options = {\n    ...options,\n    ...context.params.adapter,\n  }\n\n  return options.paginate || undefined\n}\n","import type { HookContext } from '@feathersjs/feathers'\nimport { getPaginate } from '../../utils/get-paginate/get-paginate.util.js'\n\n/**\n * Checks if the current `find` operation is paginated by inspecting\n * `params.paginate` and the service's pagination options via `getPaginate`.\n * Returns `false` for all methods other than `find` or when pagination is disabled.\n *\n * @example\n * ```ts\n * import { iff, isPaginated } from 'feathers-utils/predicates'\n *\n * app.service('users').hooks({\n *   after: { find: [iff(isPaginated, addTotalCountHeader())] }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/predicates/is-paginated.html\n */\nexport const isPaginated = <H extends HookContext = HookContext>(\n  context: H,\n): boolean => {\n  if (context.params.paginate === false || context.method !== 'find') {\n    return false\n  }\n\n  const paginate = getPaginate(context)\n\n  return !!paginate\n}\n","import { MethodNotAllowed } from '@feathersjs/errors'\nimport type { HookContext } from '@feathersjs/feathers'\nimport type { TransportName } from '../../types.js'\n\n/**\n * Returns a predicate that checks the transport provider of the service call.\n * Matches against `'rest'`, `'socketio'`, `'external'` (any external provider),\n * or `'server'` (internal call without a provider).\n *\n * @example\n * ```ts\n * import { iff, isProvider } from 'feathers-utils/predicates'\n *\n * app.service('users').hooks({\n *   before: { all: [iff(isProvider('external'), authenticate('jwt'))] }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/predicates/is-provider.html\n */\nexport function isProvider<H extends HookContext = HookContext>(\n  ...providers: TransportName[]\n) {\n  if (!providers.length) {\n    throw new MethodNotAllowed('Calling isProvider predicate incorrectly.')\n  }\n\n  return (context: H): boolean => {\n    const hookProvider = context.params.provider\n\n    return providers.some(\n      (provider) =>\n        provider === hookProvider ||\n        (provider === 'server' && !hookProvider) ||\n        (provider === 'external' && !!hookProvider),\n    )\n  }\n}\n","import type { HookContext } from '@feathersjs/feathers'\nimport { isPromise } from '../../common/index.js'\nimport type { PredicateFn } from '../../types.js'\n\n/**\n * Negates a sync or async predicate function, inverting its boolean result.\n * Useful for composing conditions like \"not external\" or \"not multi\".\n *\n * @example\n * ```ts\n * import { iff, not, isProvider } from 'feathers-utils/predicates'\n *\n * app.service('users').hooks({\n *   before: { all: [iff(not(isProvider('server')), authenticate('jwt'))] }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/predicates/not.html\n */\nexport const not =\n  <H extends HookContext = HookContext>(\n    predicate: PredicateFn<H>,\n  ): PredicateFn<H> =>\n  (context: H) => {\n    const result = predicate(context)\n\n    if (!isPromise(result)) {\n      return !result\n    }\n\n    return result.then((result1) => !result1)\n  }\n","import type { HookContext } from '@feathersjs/feathers'\nimport type { PredicateFn } from '../../types.js'\nimport { isPromise } from '../../common/index.js'\n\n/**\n * Returns a predicate that is `true` when **any** of the given predicates is `true` (logical OR).\n * Supports both sync and async predicates. Short-circuits on the first `true` result.\n * Undefined predicates in the list are skipped.\n *\n * @example\n * ```ts\n * import { iff, or, isProvider } from 'feathers-utils/predicates'\n *\n * app.service('users').hooks({\n *   before: { all: [iff(or(isProvider('rest'), isProvider('socketio')), rateLimitHook())] }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/predicates/or.html\n */\nexport const or = <H extends HookContext = HookContext>(\n  ...predicates: (PredicateFn<H> | undefined)[]\n): PredicateFn<H> => {\n  const filtered = predicates.filter(\n    (p): p is PredicateFn<H> => p !== undefined,\n  )\n\n  return (context: H): boolean | Promise<boolean> => {\n    // The identity element of logical OR is `false` (an empty OR is false).\n    if (!filtered.length) {\n      return false\n    }\n\n    const promises: Promise<boolean>[] = []\n\n    for (const predicate of filtered) {\n      const result = predicate(context)\n\n      if (isPromise(result)) {\n        promises.push(result)\n      } else if (result) {\n        // any truthy sync result short-circuits to true\n        return true\n      }\n    }\n\n    if (!promises.length) {\n      return false\n    }\n\n    return Promise.all(promises).then((results) =>\n      results.some((result) => !!result),\n    )\n  }\n}\n\n// Alias for 'some'\nexport const some = or\n","import { GeneralError } from '@feathersjs/errors'\n\nimport type { HookContext } from '@feathersjs/feathers'\nimport type { SkipHookName } from '../../utils/index.js'\n\n/**\n * Returns a predicate that checks `params.skipHooks` to determine if a hook should be skipped.\n * Matches by hook name, hook type (e.g. `'before'`), prefixed name (e.g. `'before:myHook'`),\n * or `'all'` to skip everything. Designed to be used with `skippable` and `addSkip`.\n *\n * @example\n * ```ts\n * import { skippable, shouldSkip } from 'feathers-utils/predicates'\n *\n * const myHook = skippable(actualHook(), shouldSkip('myHook'))\n * ```\n *\n * @see https://utils.feathersjs.com/predicates/should-skip.html\n */\nexport const shouldSkip = <H extends HookContext = HookContext>(\n  hookName: SkipHookName,\n) => {\n  return (context: H): boolean => {\n    if (!context.params?.skipHooks) {\n      return false\n    }\n\n    const { skipHooks } = context.params\n    if (!Array.isArray(skipHooks)) {\n      throw new GeneralError(\n        'The `skipHooks` param must be an Array of Strings',\n      )\n    }\n    const { type } = context\n    if (skipHooks.includes(hookName)) {\n      return true\n    } else if (skipHooks.includes('all')) {\n      return true\n    } else if (skipHooks.includes(type)) {\n      return true\n    } else if (skipHooks.includes(`${type}:${hookName}`)) {\n      return true\n    }\n\n    return false\n  }\n}\n","import type { HookContext, NextFunction } from '@feathersjs/feathers'\nimport { isPromise } from '../../common/index.js'\nimport { combine } from '../../utils/combine/combine.util.js'\nimport type { HookFunction, PredicateFn } from '../../types.js'\n\n/**\n * Executes one array of hooks when the predicate is truthy, or another array when it is falsy.\n * The predicate can be a boolean or a sync/async function.\n * Unlike `iff`, both branches are provided upfront without chaining.\n *\n * @example\n * ```ts\n * import { iffElse, isProvider } from 'feathers-utils/predicates'\n *\n * app.service('users').hooks({\n *   before: {\n *     find: [iffElse(isProvider('external'), [hook1()], [hook2()])]\n *   }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/hooks/iff-else.html\n */\nexport function iffElse<H extends HookContext = HookContext>(\n  predicate: boolean | PredicateFn<H>,\n  trueHook: HookFunction<H> | HookFunction<H>[] | undefined,\n  falseHook?: HookFunction<H> | HookFunction<H>[] | undefined,\n) {\n  // fnArgs is [context] for service & permission hooks, [data, connection, context] for event filters\n  return function (this: any, ctx: H, next?: NextFunction) {\n    const trueHooks = Array.isArray(trueHook)\n      ? trueHook\n      : typeof trueHook === 'function'\n        ? [trueHook]\n        : undefined\n\n    const falseHooks = Array.isArray(falseHook)\n      ? falseHook\n      : typeof falseHook === 'function'\n        ? [falseHook]\n        : undefined\n\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    const that = this\n    const check =\n      typeof predicate === 'function'\n        ? predicate.apply(that, [ctx])\n        : !!predicate\n\n    if (!isPromise(check)) {\n      return callHooks.call(\n        that,\n        ctx,\n        (check ? trueHooks : falseHooks) as any,\n        next,\n      )\n    }\n\n    return check.then((check1: any) => {\n      const hooks = check1 ? trueHooks : falseHooks\n      return callHooks.call(that, ctx, hooks as any, next)\n    })\n  }\n}\n\nfunction callHooks<H extends HookContext = HookContext>(\n  this: any,\n  ctx: H,\n  serviceHooks: HookFunction<H>[],\n  next?: NextFunction,\n) {\n  if (!serviceHooks) {\n    if (next) return next()\n    return ctx\n  }\n\n  const result = combine(...serviceHooks).call(this, ctx)\n\n  if (!next) return result\n\n  return Promise.resolve(result).then(() => next())\n}\n","import type { HookContext, NextFunction } from '@feathersjs/feathers'\nimport { iffElse } from '../iff-else/iff-else.hook.js'\nimport type { HookFunction, PredicateFn } from '../../types.js'\n\nexport interface IffHook<\n  H extends HookContext = HookContext,\n> extends HookFunction<H> {\n  else(...hooks: HookFunction<H>[]): HookFunction<H>\n}\n\n/**\n * Conditionally executes a series of hooks when the predicate is truthy.\n * The predicate can be a boolean value or a sync/async function.\n * Supports an `.else(...)` chain for the falsy branch. Also exported as `when`.\n *\n * @example\n * ```ts\n * import { iff, isProvider } from 'feathers-utils/predicates'\n *\n * app.service('users').hooks({\n *   before: {\n *     find: [iff(isProvider('external'), authenticate('jwt'))]\n *   }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/hooks/iff.html\n */\nexport function iff<H extends HookContext = HookContext>(\n  predicate: boolean | PredicateFn<H>,\n  ...hooks: HookFunction<H>[]\n): IffHook<H> {\n  if (hooks.length && Array.isArray(hooks[0])) {\n    hooks = hooks[0]\n  }\n\n  const iffWithoutElse = function (context: H, next?: NextFunction) {\n    return iffElse(predicate, hooks.slice())(context, next)\n  }\n\n  iffWithoutElse.else =\n    (...falseHooks: any[]) =>\n    (context: H, next?: NextFunction) =>\n      iffElse(predicate, hooks.slice(), falseHooks.slice())(context, next)\n\n  return iffWithoutElse as IffHook<H>\n}\n\nexport { iff as when }\n","import type { HookContext, NextFunction } from '@feathersjs/feathers'\nimport type { HookFunction, PredicateFn } from '../../types.js'\n\n/**\n * Wraps a hook so it can be conditionally skipped based on a predicate.\n * When the predicate returns `true`, the wrapped hook is skipped entirely.\n * Commonly used with `shouldSkip` and `addSkip` for runtime hook control.\n *\n * @example\n * ```ts\n * import { skippable, shouldSkip } from 'feathers-utils/predicates'\n *\n * const myHook = skippable(someHook(), shouldSkip('someHook'))\n * ```\n *\n * @see https://utils.feathersjs.com/hooks/skippable.html\n */\nexport const skippable = <H extends HookContext = HookContext>(\n  innerHook: HookFunction<H>,\n  predicate: PredicateFn<H>,\n) => {\n  function hook(context: H): H | void | Promise<H | void>\n  function hook(context: H, next: NextFunction): Promise<void>\n  function hook(context: H, next?: NextFunction): H | void | Promise<H | void> {\n    const skip = predicate(context)\n\n    const skipOrRun = (shouldSkip: boolean): H | void | Promise<H | void> => {\n      if (shouldSkip) {\n        if (next) return next()\n        return\n      }\n      if (next) return innerHook(context, next) as Promise<void>\n      // before/after mode: return the inner hook's result so an async hook is\n      // awaited and a returned/modified context is propagated to the pipeline.\n      return innerHook(context)\n    }\n\n    if (!skip || typeof skip === 'boolean') {\n      return skipOrRun(skip)\n    }\n\n    return skip.then(skipOrRun) as Promise<void>\n  }\n  return hook\n}\n","import type { HookContext, NextFunction } from '@feathersjs/feathers'\nimport type { PredicateFn } from '../../types.js'\nimport { BadRequest } from '@feathersjs/errors'\nimport type { FeathersError } from '@feathersjs/errors'\n\nexport type ThrowIfOptions = {\n  /**\n   * Customize the error that is thrown if the predicate returns true.\n   *\n   * If not provided, throws a `BadRequest` error with 'Invalid operation'.\n   */\n  error?: (context: HookContext) => FeathersError\n}\n\n/**\n * Throws a `BadRequest` error when the given predicate function returns `true`.\n * The predicate receives the hook context and can be async.\n * Useful for validating conditions before proceeding with a request.\n *\n * @example\n * ```ts\n * import { throwIf } from 'feathers-utils/hooks'\n *\n * app.service('users').hooks({\n *   before: { remove: [throwIf((context) => context.id === context.params.user?.id)] }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/hooks/throw-if.html\n */\nexport const throwIf = <H extends HookContext = HookContext>(\n  predicate: PredicateFn,\n  options?: ThrowIfOptions,\n) => {\n  return async (context: H, next?: NextFunction): Promise<void> => {\n    const result = await predicate(context)\n\n    if (result) {\n      throw options?.error\n        ? options.error(context)\n        : new BadRequest('Invalid operation')\n    }\n\n    if (next) {\n      await next()\n    }\n  }\n}\n","import type { HookContext } from '@feathersjs/feathers'\nimport { iffElse } from '../iff-else/iff-else.hook.js'\nimport type { PredicateFn, HookFunction } from '../../types.js'\n\n/**\n * Executes a series of hooks when the predicate is falsy --- the inverse of `iff`.\n * The predicate can be a boolean or a sync/async function.\n * Useful for applying hooks to all contexts except those matching a condition.\n *\n * @example\n * ```ts\n * import { unless, isProvider } from 'feathers-utils/predicates'\n *\n * app.service('users').hooks({\n *   before: { all: [unless(isProvider('server'), authenticate('jwt'))] }\n * })\n * ```\n *\n * @see https://utils.feathersjs.com/hooks/unless.html\n */\nexport function unless<H extends HookContext = HookContext>(\n  predicate: boolean | PredicateFn,\n  ...hooks: HookFunction<H>[]\n) {\n  return iffElse(predicate, undefined, [...hooks])\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,SAAgB,QACd,GAAG,cACH;CACA,MAAM,YAAY,SAAU,KAAQ;EAClC,OAAO,OAAO,KAAK,WAAW,YAAY,OAAO,KAAK,SAAS;CACjE;CAEA,OAAO,eAAgB,SAAY;EACjC,IAAI,MAAM;EAEV,MAAM,qBAAqB,YAAsB;GAG/C,IAAI,SAAS;IACX,IAAI,CAAC,UAAU,OAAO,GACpB,MAAM,IAAI,MACR,GAAG,IAAI,KAAK,aAAa,IAAI,OAAO,sCACtC;IAGF,MAAM;GACR;GAEA,OAAO;EACT;EAIA,IAAI;GACF,KAAK,MAAM,MAAM,cAAc;IAE7B,MAAM,aAAa,GAAG,KAAK,MAAM,GAAG;IACpC,kBAAkB,UAAU,UAAU,IAAI,MAAM,aAAa,UAAU;GACzE;GACA,OAAO;EACT,SAAS,OAAY;GAEnB,MAAM,OAAO;GACb,MAAM;EACR;CACF;AACF;;;;;;;;;;;;;;;;;;;ACxCA,MAAa,OACX,GAAG,eACgB;CACnB,MAAM,WAAW,WAAW,QACzB,MAA2B,MAAM,KAAA,CACpC;CAEA,QAAQ,YAA2C;EAEjD,IAAI,CAAC,SAAS,QACZ,OAAO;EAGT,MAAM,WAA+B,CAAC;EAEtC,KAAK,MAAM,aAAa,UAAU;GAChC,MAAM,SAAS,UAAU,OAAO;GAChC,IAAI,UAAU,MAAM,GAClB,SAAS,KAAK,MAAM;QACf,IAAI,CAAC,QAEV,OAAO;EAEX;EAEA,IAAI,CAAC,SAAS,QACZ,OAAO;EAGT,OAAO,QAAQ,IAAI,QAAQ,CAAC,CAAC,MAAM,YACjC,QAAQ,OAAO,WAAW,CAAC,CAAC,MAAM,CACpC;CACF;AACF;AAGA,MAAa,QAAQ;;;;;;;;;;;;;;;;;;;AC9BrB,MAAa,aACX,YACG;CACH,MAAM,OAAO,QAAQ,QAAQ,OAAO,QAAQ,QAAQ,IAAI,IAAI,KAAA;CAC5D,MAAM,OAAO,QAAQ,QAAQ,OAAO,QAAQ,QAAQ,IAAI,IAAI,KAAA;CAC5D,MAAM,SAAS,QAAQ,UAAU,OAAO,QAAQ,QAAQ,MAAM,IAAI,KAAA;CAElE,QAAQ,YAA0B;EAChC,IAAI,QAAQ,CAAC,KAAK,MAAM,MAAM,QAAQ,SAAS,CAAC,GAC9C,OAAO;EAGT,IAAI,QAAQ,CAAC,KAAK,MAAM,MAAM,QAAQ,SAAS,CAAC,GAC9C,OAAO;EAGT,IAAI,UAAU,CAAC,OAAO,MAAM,MAAM,QAAQ,WAAW,CAAC,GACpD,OAAO;EAGT,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;AC9BA,MAAa,WACX,YACY;CACZ,MAAM,EAAE,WAAW;CACnB,IAAI,WAAW,QACb,OAAO;MACF,IAAI,WAAW,WAAW,WAAW,UAC1C,OAAO,QAAQ,MAAM;MAChB,IAAI,WAAW,UACpB,OAAO,MAAM,QAAQ,QAAQ,IAAI;MAC5B,IAAI,WAAW,SAAS,WAAW,UACxC,OAAO;CAGT,OAAO;AACT;;;;;;;;;;;;;;;;;;;;ACZA,MAAa,eACX,YACkC;CAClC,IAAI,eAAe,QAAQ,QAAQ,UAAU,GAE3C,OAAQ,QAAQ,OAAO,YAAkC,KAAA;CAG3D,IAAI,UAAU,QAAQ,SAAS,WAAW,CAAC;CAE3C,UAAU;EACR,GAAG;EACH,GAAG,QAAQ,OAAO;CACpB;CAEA,OAAO,QAAQ,YAAY,KAAA;AAC7B;;;;;;;;;;;;;;;;;;;AClBA,MAAa,eACX,YACY;CACZ,IAAI,QAAQ,OAAO,aAAa,SAAS,QAAQ,WAAW,QAC1D,OAAO;CAKT,OAAO,CAAC,CAFS,YAAY,OAEb;AAClB;;;;;;;;;;;;;;;;;;;ACTA,SAAgB,WACd,GAAG,WACH;CACA,IAAI,CAAC,UAAU,QACb,MAAM,IAAI,iBAAiB,2CAA2C;CAGxE,QAAQ,YAAwB;EAC9B,MAAM,eAAe,QAAQ,OAAO;EAEpC,OAAO,UAAU,MACd,aACC,aAAa,gBACZ,aAAa,YAAY,CAAC,gBAC1B,aAAa,cAAc,CAAC,CAAC,YAClC;CACF;AACF;;;;;;;;;;;;;;;;;;AClBA,MAAa,OAET,eAED,YAAe;CACd,MAAM,SAAS,UAAU,OAAO;CAEhC,IAAI,CAAC,UAAU,MAAM,GACnB,OAAO,CAAC;CAGV,OAAO,OAAO,MAAM,YAAY,CAAC,OAAO;AAC1C;;;;;;;;;;;;;;;;;;;ACXF,MAAa,MACX,GAAG,eACgB;CACnB,MAAM,WAAW,WAAW,QACzB,MAA2B,MAAM,KAAA,CACpC;CAEA,QAAQ,YAA2C;EAEjD,IAAI,CAAC,SAAS,QACZ,OAAO;EAGT,MAAM,WAA+B,CAAC;EAEtC,KAAK,MAAM,aAAa,UAAU;GAChC,MAAM,SAAS,UAAU,OAAO;GAEhC,IAAI,UAAU,MAAM,GAClB,SAAS,KAAK,MAAM;QACf,IAAI,QAET,OAAO;EAEX;EAEA,IAAI,CAAC,SAAS,QACZ,OAAO;EAGT,OAAO,QAAQ,IAAI,QAAQ,CAAC,CAAC,MAAM,YACjC,QAAQ,MAAM,WAAW,CAAC,CAAC,MAAM,CACnC;CACF;AACF;AAGA,MAAa,OAAO;;;;;;;;;;;;;;;;;ACtCpB,MAAa,cACX,aACG;CACH,QAAQ,YAAwB;EAC9B,IAAI,CAAC,QAAQ,QAAQ,WACnB,OAAO;EAGT,MAAM,EAAE,cAAc,QAAQ;EAC9B,IAAI,CAAC,MAAM,QAAQ,SAAS,GAC1B,MAAM,IAAI,aACR,mDACF;EAEF,MAAM,EAAE,SAAS;EACjB,IAAI,UAAU,SAAS,QAAQ,GAC7B,OAAO;OACF,IAAI,UAAU,SAAS,KAAK,GACjC,OAAO;OACF,IAAI,UAAU,SAAS,IAAI,GAChC,OAAO;OACF,IAAI,UAAU,SAAS,GAAG,KAAK,GAAG,UAAU,GACjD,OAAO;EAGT,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;;;ACvBA,SAAgB,QACd,WACA,UACA,WACA;CAEA,OAAO,SAAqB,KAAQ,MAAqB;EACvD,MAAM,YAAY,MAAM,QAAQ,QAAQ,IACpC,WACA,OAAO,aAAa,aAClB,CAAC,QAAQ,IACT,KAAA;EAEN,MAAM,aAAa,MAAM,QAAQ,SAAS,IACtC,YACA,OAAO,cAAc,aACnB,CAAC,SAAS,IACV,KAAA;EAGN,MAAM,OAAO;EACb,MAAM,QACJ,OAAO,cAAc,aACjB,UAAU,MAAM,MAAM,CAAC,GAAG,CAAC,IAC3B,CAAC,CAAC;EAER,IAAI,CAAC,UAAU,KAAK,GAClB,OAAO,UAAU,KACf,MACA,KACC,QAAQ,YAAY,YACrB,IACF;EAGF,OAAO,MAAM,MAAM,WAAgB;GACjC,MAAM,QAAQ,SAAS,YAAY;GACnC,OAAO,UAAU,KAAK,MAAM,KAAK,OAAc,IAAI;EACrD,CAAC;CACH;AACF;AAEA,SAAS,UAEP,KACA,cACA,MACA;CACA,IAAI,CAAC,cAAc;EACjB,IAAI,MAAM,OAAO,KAAK;EACtB,OAAO;CACT;CAEA,MAAM,SAAS,QAAQ,GAAG,YAAY,CAAC,CAAC,KAAK,MAAM,GAAG;CAEtD,IAAI,CAAC,MAAM,OAAO;CAElB,OAAO,QAAQ,QAAQ,MAAM,CAAC,CAAC,WAAW,KAAK,CAAC;AAClD;;;;;;;;;;;;;;;;;;;;;ACrDA,SAAgB,IACd,WACA,GAAG,OACS;CACZ,IAAI,MAAM,UAAU,MAAM,QAAQ,MAAM,EAAE,GACxC,QAAQ,MAAM;CAGhB,MAAM,iBAAiB,SAAU,SAAY,MAAqB;EAChE,OAAO,QAAQ,WAAW,MAAM,MAAM,CAAC,CAAC,CAAC,SAAS,IAAI;CACxD;CAEA,eAAe,QACZ,GAAG,gBACH,SAAY,SACX,QAAQ,WAAW,MAAM,MAAM,GAAG,WAAW,MAAM,CAAC,CAAC,CAAC,SAAS,IAAI;CAEvE,OAAO;AACT;;;;;;;;;;;;;;;;;AC7BA,MAAa,aACX,WACA,cACG;CAGH,SAAS,KAAK,SAAY,MAAmD;EAC3E,MAAM,OAAO,UAAU,OAAO;EAE9B,MAAM,aAAa,eAAsD;GACvE,IAAI,YAAY;IACd,IAAI,MAAM,OAAO,KAAK;IACtB;GACF;GACA,IAAI,MAAM,OAAO,UAAU,SAAS,IAAI;GAGxC,OAAO,UAAU,OAAO;EAC1B;EAEA,IAAI,CAAC,QAAQ,OAAO,SAAS,WAC3B,OAAO,UAAU,IAAI;EAGvB,OAAO,KAAK,KAAK,SAAS;CAC5B;CACA,OAAO;AACT;;;;;;;;;;;;;;;;;;;ACdA,MAAa,WACX,WACA,YACG;CACH,OAAO,OAAO,SAAY,SAAuC;EAG/D,IAAI,MAFiB,UAAU,OAAO,GAGpC,MAAM,SAAS,QACX,QAAQ,MAAM,OAAO,IACrB,IAAI,WAAW,mBAAmB;EAGxC,IAAI,MACF,MAAM,KAAK;CAEf;AACF;;;;;;;;;;;;;;;;;;;AC3BA,SAAgB,OACd,WACA,GAAG,OACH;CACA,OAAO,QAAQ,WAAW,KAAA,GAAW,CAAC,GAAG,KAAK,CAAC;AACjD"}