yummies 7.11.0 → 7.13.0

package/mobx.js.map

@@ -1 +1 @@
-{"version":3,"file":"mobx.js","sources":["../src/mobx/apply-observable.ts","../src/mobx/create-enhanced-atom.ts","../src/mobx/create-ref.ts","../src/mobx/deep-observable-struct.ts","../src/mobx/get-mobx-administration.ts","../src/mobx/lazy-observe.ts"],"sourcesContent":["import { type AnnotationMapEntry, makeObservable } from 'mobx';\nimport type { AnyObject } from 'yummies/types';\n\nexport type ObservableAnnotationsArray<T extends AnyObject = AnyObject> = [\n  AnnotationMapEntry,\n  ...(keyof T | (string & {}))[],\n][];\n\n/**\n * Applies a compact list of MobX annotations to an object using either\n * decorator-style invocation or the annotation map form accepted by `makeObservable`.\n *\n * @template T Target object type.\n * @param context Object that should become observable.\n * @param annotationsArray Tuples of annotation followed by annotated field names.\n * @param useDecorators Enables decorator-style application before calling `makeObservable`.\n *\n * @example\n * ```ts\n * applyObservable(store, [[observable, 'items'], [action, 'setItems']]);\n * ```\n *\n * @example\n * ```ts\n * applyObservable(viewModel, [[computed, 'fullName']], true);\n * ```\n */\nexport const applyObservable = <T extends AnyObject>(\n  context: T,\n  annotationsArray: ObservableAnnotationsArray<T>,\n  useDecorators?: boolean,\n) => {\n  if (useDecorators) {\n    annotationsArray.forEach(([annotation, ...fields]) => {\n      fields.forEach((field) => {\n        // @ts-expect-error\n        annotation(context, field);\n      });\n    });\n\n    makeObservable(context);\n  } else {\n    const annotationsObject: AnyObject = {};\n\n    annotationsArray.forEach(([annotation, ...fields]) => {\n      fields.forEach((field) => {\n        annotationsObject[field] = annotation;\n      });\n    });\n\n    makeObservable(context, annotationsObject);\n  }\n};\n","import { createAtom, type IAtom } from 'mobx';\nimport type { AnyObject } from 'yummies/types';\n\nexport interface IEnhancedAtom<TMeta extends AnyObject = AnyObject>\n  extends IAtom {\n  meta: TMeta;\n}\n\n/**\n * Creates a MobX atom extended with metadata and bound reporting methods.\n *\n * @template TMeta Metadata object stored on the atom.\n * @param name Atom name used by MobX for debugging.\n * @param onBecomeObservedHandler Callback fired when the atom becomes observed.\n * @param onBecomeUnobservedHandler Callback fired when the atom is no longer observed.\n * @param meta Optional metadata attached to the atom.\n * @returns Atom instance with `meta`, `reportChanged` and `reportObserved`.\n *\n * @example\n * ```ts\n * const atom = createEnhancedAtom('user-status');\n * atom.reportChanged();\n * ```\n *\n * @example\n * ```ts\n * const atom = createEnhancedAtom('cache', undefined, undefined, { scope: 'users' });\n * atom.meta.scope;\n * ```\n */\nexport const createEnhancedAtom = <TMeta extends AnyObject>(\n  name: string,\n  onBecomeObservedHandler?: (atom: IEnhancedAtom<TMeta>) => void,\n  onBecomeUnobservedHandler?: (atom: IEnhancedAtom<TMeta>) => void,\n  meta?: TMeta,\n): IEnhancedAtom<TMeta> => {\n  const atom = createAtom(\n    name,\n    onBecomeObservedHandler && (() => onBecomeObservedHandler(atom)),\n    onBecomeUnobservedHandler && (() => onBecomeUnobservedHandler(atom)),\n  ) as IEnhancedAtom<TMeta>;\n  atom.meta = meta ?? ({} as TMeta);\n  atom.reportChanged = atom.reportChanged.bind(atom);\n  atom.reportObserved = atom.reportObserved.bind(atom);\n  return atom;\n};\n","import {\n  type IEqualsComparer,\n  makeObservable,\n  comparer as mobxComparer,\n  observable,\n  runInAction,\n} from 'mobx';\nimport type { AnyObject, Maybe } from 'yummies/types';\n\n/**\n * You can return `false` if you don't want to change the value in this ref\n */\nexport type RefChangeListener<T> = (\n  value: T | null,\n  prevValue: T | undefined,\n) => void | false;\n\n/**\n * Alternative to React.createRef but works in MobX world.\n * Typically it the should be the same React.LegacyRef (fn style)\n */\nexport interface Ref<T = any, TMeta = AnyObject> {\n  /**\n   * Setter function\n   */\n  (value: Maybe<T>): void;\n\n  set(value: Maybe<T>): void;\n  listeners: Set<RefChangeListener<NoInfer<T>>>;\n  current: NoInfer<T> | null;\n  meta: TMeta;\n}\n\nexport interface CreateRefConfig<T = any, TMeta = AnyObject> {\n  onSet?: (node: T, prevValue: T | undefined) => void;\n  onUnset?: (lastValue: T | undefined) => void;\n  onChange?: RefChangeListener<T>;\n  meta?: TMeta;\n  initial?: Maybe<T>;\n  comparer?: IEqualsComparer<T | null>;\n}\n\n/**\n * Creates a MobX-aware ref that behaves like a callback ref and exposes\n * observable `current` and `meta` fields.\n *\n * @template T Referenced value type.\n * @template TMeta Additional observable metadata stored on the ref.\n * @param cfg Optional callbacks, initial value and comparer configuration.\n * @returns Observable ref function object.\n *\n * @example\n * ```ts\n * const inputRef = createRef<HTMLInputElement>();\n * inputRef.set(document.createElement('input'));\n * ```\n *\n * @example\n * ```ts\n * const nodeRef = createRef({\n *   onUnset: () => console.log('detached'),\n *   meta: { mounted: false },\n * });\n * ```\n */\nexport const createRef = <T = any, TMeta = AnyObject>(\n  cfg?: CreateRefConfig<T, TMeta>,\n): Ref<T, TMeta> => {\n  let lastValue: T | undefined;\n  const comparer = cfg?.comparer ?? mobxComparer.default;\n\n  const setValue: Ref<T, TMeta>['set'] = (value) => {\n    const nextValue = value ?? null;\n\n    if (comparer(ref.current, nextValue)) {\n      return;\n    }\n\n    runInAction(() => {\n      const prevLastValue = lastValue;\n      lastValue = ref.current ?? undefined;\n      ref.current = nextValue;\n\n      let isNextValueIgnored = false;\n\n      ref.listeners.forEach((listener) => {\n        const listenerResult = listener(ref.current, lastValue);\n\n        if (listenerResult === false) {\n          isNextValueIgnored = true;\n        }\n      });\n\n      if (isNextValueIgnored) {\n        lastValue = prevLastValue;\n        ref.current = lastValue ?? null;\n      } else if (ref.current === null && lastValue !== undefined) {\n        lastValue = undefined;\n      }\n    });\n  };\n\n  const ref = setValue as Ref<T, TMeta>;\n\n  ref.set = setValue;\n\n  ref.listeners = new Set(cfg?.onChange ? [cfg.onChange] : []);\n\n  if (cfg?.onSet || cfg?.onUnset) {\n    ref.listeners.add((value, prevValue) => {\n      if (value) {\n        cfg.onSet?.(value, prevValue);\n      } else {\n        cfg.onUnset?.(prevValue);\n      }\n    });\n  }\n\n  ref.current = cfg?.initial ?? null;\n  ref.meta = cfg?.meta ?? ({} as TMeta);\n\n  makeObservable(ref, {\n    current: observable.ref,\n    meta: observable,\n  });\n\n  return ref;\n};\n\n/**\n * Checks whether the provided value is a ref created by `createRef`.\n *\n * @template T Referenced value type.\n * @template TMeta Ref metadata type.\n * @param value Value to inspect.\n * @returns `true` when the value is a ref-like function with `current`.\n *\n * @example\n * ```ts\n * const ref = createRef<number>();\n * isRef(ref); // true\n * ```\n *\n * @example\n * ```ts\n * isRef({ current: 1 }); // false\n * ```\n */\nexport const isRef = <T, TMeta = any>(\n  value: T | Ref<T, TMeta>,\n): value is Ref<T, TMeta> => {\n  return typeof value === 'function' && 'current' in value;\n};\n\n/**\n * Normalizes a plain value or an existing ref into a `Ref` instance.\n *\n * @template T Referenced value type.\n * @template TMeta Ref metadata type.\n * @param value Existing ref or initial plain value.\n * @param cfg Optional ref configuration applied when a new ref is created.\n * @returns Existing ref or a newly created ref initialized with `value`.\n *\n * @example\n * ```ts\n * const ref = toRef(document.body);\n * ref.current === document.body;\n * ```\n *\n * @example\n * ```ts\n * const existingRef = createRef<number>();\n * const sameRef = toRef(existingRef);\n * ```\n */\nexport const toRef = <T, TMeta = any>(\n  value: T | Ref<T, TMeta>,\n  cfg?: Omit<CreateRefConfig<T, TMeta>, 'initial'>,\n): Ref<T, TMeta> => {\n  return isRef(value) ? value : createRef({ initial: value, ...cfg });\n};\n","import { action, makeObservable, observable } from 'mobx';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { AnyObject } from 'yummies/types';\n\n/**\n * Wraps a plain object into a deeply observable structure and allows\n * patch-like updates while preserving nested observable references where possible.\n *\n * @template TData Observable object shape.\n *\n * @example\n * ```ts\n * const state = new DeepObservableStruct({ user: { name: 'Ann' } });\n * state.set({ user: { name: 'Bob' } });\n * ```\n *\n * @example\n * ```ts\n * const state = new DeepObservableStruct({ filters: { active: true } });\n * state.set({ filters: { active: false, archived: true } });\n * ```\n */\nexport class DeepObservableStruct<TData extends AnyObject> {\n  data: TData;\n\n  constructor(data: TData) {\n    this.data = data;\n\n    makeObservable(this, {\n      data: observable.deep,\n      set: action,\n    });\n  }\n\n  set(newData: Partial<TData>) {\n    type StackItem = [key: string, currObservable: AnyObject, new: AnyObject];\n\n    const stack: StackItem[] = Object.keys(this.data).map((key) => [\n      key,\n      this.data,\n      newData,\n    ]);\n\n    let currentIndex = 0;\n    let stackLength = stack.length;\n\n    while (currentIndex < stackLength) {\n      const [key, currObservableData, newData] = stack[currentIndex];\n      const newValue = newData[key];\n      const currValue = currObservableData[key];\n\n      currentIndex++;\n\n      if (key in newData) {\n        if (typeGuard.isObject(newValue) && typeGuard.isObject(currValue)) {\n          const newValueKeys = Object.keys(newValue);\n\n          Object.keys(currValue).forEach((childKey) => {\n            if (!(childKey in newValue)) {\n              delete currObservableData[key][childKey];\n            }\n          });\n\n          newValueKeys.forEach((childKey) => {\n            const length = stack.push([\n              childKey,\n              currObservableData[key],\n              newValue,\n            ]);\n            stackLength = length;\n          });\n        } else if (newValue !== currValue) {\n          currObservableData[key] = newValue;\n        }\n      } else {\n        delete currObservableData[key];\n      }\n    }\n\n    Object.keys(newData).forEach((newDataKey) => {\n      if (!this.data[newDataKey]) {\n        // @ts-expect-error\n        this.data[newDataKey] = newData[newDataKey];\n      }\n    });\n  }\n}\n","import { $mobx, type AnnotationMapEntry } from 'mobx';\nimport type { AnyObject } from 'yummies/types';\n\ntype ObservableObjectAdministration = Parameters<\n  Exclude<AnnotationMapEntry, boolean>['make_']\n>[0];\n\n/**\n * Returns the internal MobX administration object associated with an observable target.\n *\n * @param context Observable object instance.\n * @returns MobX administration internals stored under `$mobx`.\n *\n * @example\n * ```ts\n * const admin = getMobxAdministration(store);\n * admin.name_;\n * ```\n *\n * @example\n * ```ts\n * const values = getMobxAdministration(formState).values_;\n * ```\n */\nexport const getMobxAdministration = (\n  context: AnyObject,\n): ObservableObjectAdministration => context[$mobx];\n","import { onBecomeObserved, onBecomeUnobserved } from 'mobx';\n\n/**\n * Starts side effects only while one or more MobX observables are being observed.\n *\n * When the first property becomes observed, `onStart` is called. When all tracked\n * properties become unobserved, `onEnd` is called with the value returned by\n * `onStart`. Cleanup can be delayed via `endDelay`.\n *\n * It uses MobX `onBecomeObserved` and `onBecomeUnobserved` hooks to perform\n * lazy subscription management.\n *\n * @template TMetaData Data returned from `onStart` and forwarded to `onEnd`.\n * @param config Configuration for tracked properties and lifecycle callbacks.\n * @returns Cleanup function that clears the tracked state and runs `onEnd`.\n *\n * @example\n * ```ts\n * const stop = lazyObserve({\n *   context: store,\n *   property: 'items',\n *   onStart: () => api.subscribe(),\n *   onEnd: (subscription) => subscription.unsubscribe(),\n * });\n * ```\n *\n * @example\n * ```ts\n * lazyObserve({\n *   property: [boxA, boxB],\n *   onStart: () => console.log('observed'),\n *   endDelay: 300,\n * });\n * ```\n */\nexport const lazyObserve = <TMetaData = void>({\n  context,\n  property,\n  onStart,\n  onEnd,\n  endDelay = false,\n}: {\n  context?: any;\n  property: any | any[];\n  onStart?: () => TMetaData;\n  onEnd?: (metaData: TMetaData, cleanupFn: VoidFunction) => void;\n  endDelay?: number | false;\n}) => {\n  let timeoutId: ReturnType<typeof setTimeout> | undefined;\n  let metaData: TMetaData | undefined;\n  const observingProps = new Set<string>();\n  const properties = Array.isArray(property) ? property : [property];\n\n  const cleanup = () => {\n    observingProps.clear();\n\n    if (endDelay === false) {\n      onEnd?.(metaData!, cleanup);\n      metaData = undefined;\n      return;\n    }\n\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n      timeoutId = undefined;\n    }\n\n    timeoutId = setTimeout(() => {\n      onEnd?.(metaData!, cleanup);\n      timeoutId = undefined;\n      metaData = undefined;\n    }, endDelay);\n  };\n\n  const start = (property: string) => {\n    const isAlreadyObserving = observingProps.size > 0;\n    observingProps.add(property);\n\n    if (isAlreadyObserving) {\n      return;\n    }\n\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n      timeoutId = undefined;\n    }\n\n    metaData = onStart?.();\n  };\n\n  const stop = (property: string) => {\n    const isAlreadyNotObserving = !observingProps.size;\n\n    observingProps.delete(property);\n\n    const isObserving = observingProps.size > 0;\n\n    if (isAlreadyNotObserving || isObserving) {\n      return;\n    }\n\n    cleanup();\n  };\n\n  properties.forEach((property) => {\n    if (context) {\n      onBecomeObserved(context, property, () => start(property));\n      onBecomeUnobserved(context, property, () => stop(property));\n    } else {\n      onBecomeObserved(property, () => start(property));\n      onBecomeUnobserved(property, () => stop(property));\n    }\n  });\n\n  return cleanup;\n};\n"],"names":["comparer","mobxComparer","newData","property"],"mappings":"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"}
+{"version":3,"file":"mobx.js","names":[],"sources":["../src/mobx/apply-observable.ts","../src/mobx/create-enhanced-atom.ts","../src/mobx/create-ref.ts","../src/mobx/deep-observable-struct.ts","../src/mobx/get-mobx-administration.ts","../src/mobx/lazy-observe.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/mobx\n *\n * ## Description\n *\n * Compact **MobX `makeObservable`** wiring from tuple lists of annotations and keys. Reduces boilerplate\n * when many fields share `observable`, `action`, or `computed` decorators and you want one call site\n * instead of sprawling annotation maps across large stores.\n *\n * ## Usage\n *\n * ```ts\n * import { applyObservable } from \"yummies/mobx\";\n * ```\n */\n\nimport { type AnnotationMapEntry, makeObservable } from 'mobx';\nimport type { AnyObject } from 'yummies/types';\n\nexport type ObservableAnnotationsArray<T extends AnyObject = AnyObject> = [\n  AnnotationMapEntry,\n  ...(keyof T | (string & {}))[],\n][];\n\n/**\n * Applies a compact list of MobX annotations to an object using either\n * decorator-style invocation or the annotation map form accepted by `makeObservable`.\n *\n * @template T Target object type.\n * @param context Object that should become observable.\n * @param annotationsArray Tuples of annotation followed by annotated field names.\n * @param useDecorators Enables decorator-style application before calling `makeObservable`.\n *\n * @example\n * ```ts\n * applyObservable(store, [[observable, 'items'], [action, 'setItems']]);\n * ```\n *\n * @example\n * ```ts\n * applyObservable(viewModel, [[computed, 'fullName']], true);\n * ```\n */\nexport const applyObservable = <T extends AnyObject>(\n  context: T,\n  annotationsArray: ObservableAnnotationsArray<T>,\n  useDecorators?: boolean,\n) => {\n  if (useDecorators) {\n    annotationsArray.forEach(([annotation, ...fields]) => {\n      fields.forEach((field) => {\n        // @ts-expect-error\n        annotation(context, field);\n      });\n    });\n\n    makeObservable(context);\n  } else {\n    const annotationsObject: AnyObject = {};\n\n    annotationsArray.forEach(([annotation, ...fields]) => {\n      fields.forEach((field) => {\n        annotationsObject[field] = annotation;\n      });\n    });\n\n    makeObservable(context, annotationsObject);\n  }\n};\n","/**\n * ---header-docs-section---\n * # yummies/mobx\n *\n * ## Description\n *\n * **`createAtom` wrapper** that attaches arbitrary metadata and keeps MobX’s observed/unobserved\n * hooks in one place. Useful for custom reactive primitives, async resources, or debugging atoms\n * where the stock API is too bare.\n *\n * ## Usage\n *\n * ```ts\n * import { createEnhancedAtom } from \"yummies/mobx\";\n * ```\n */\n\nimport { createAtom, type IAtom } from 'mobx';\nimport type { AnyObject } from 'yummies/types';\n\nexport interface IEnhancedAtom<TMeta extends AnyObject = AnyObject>\n  extends IAtom {\n  meta: TMeta;\n}\n\n/**\n * Creates a MobX atom extended with metadata and bound reporting methods.\n *\n * @template TMeta Metadata object stored on the atom.\n * @param name Atom name used by MobX for debugging.\n * @param onBecomeObservedHandler Callback fired when the atom becomes observed.\n * @param onBecomeUnobservedHandler Callback fired when the atom is no longer observed.\n * @param meta Optional metadata attached to the atom.\n * @returns Atom instance with `meta`, `reportChanged` and `reportObserved`.\n *\n * @example\n * ```ts\n * const atom = createEnhancedAtom('user-status');\n * atom.reportChanged();\n * ```\n *\n * @example\n * ```ts\n * const atom = createEnhancedAtom('cache', undefined, undefined, { scope: 'users' });\n * atom.meta.scope;\n * ```\n */\nexport const createEnhancedAtom = <TMeta extends AnyObject>(\n  name: string,\n  onBecomeObservedHandler?: (atom: IEnhancedAtom<TMeta>) => void,\n  onBecomeUnobservedHandler?: (atom: IEnhancedAtom<TMeta>) => void,\n  meta?: TMeta,\n): IEnhancedAtom<TMeta> => {\n  const atom = createAtom(\n    name,\n    onBecomeObservedHandler && (() => onBecomeObservedHandler(atom)),\n    onBecomeUnobservedHandler && (() => onBecomeUnobservedHandler(atom)),\n  ) as IEnhancedAtom<TMeta>;\n  atom.meta = meta ?? ({} as TMeta);\n  atom.reportChanged = atom.reportChanged.bind(atom);\n  atom.reportObserved = atom.reportObserved.bind(atom);\n  return atom;\n};\n","/**\n * ---header-docs-section---\n * # yummies/mobx\n *\n * ## Description\n *\n * **Observable ref** pattern for MobX: boxed mutable references with change listeners, metadata,\n * and optional custom equality. Bridges React-style ref holders and MobX reactivity when a single\n * mutable cell must notify dependents without replacing the whole parent object graph.\n *\n * ## Usage\n *\n * ```ts\n * import { createRef } from \"yummies/mobx\";\n * ```\n */\n\nimport {\n  type IEqualsComparer,\n  makeObservable,\n  comparer as mobxComparer,\n  observable,\n  runInAction,\n} from 'mobx';\nimport type { AnyObject, Maybe } from 'yummies/types';\n\n/**\n * You can return `false` if you don't want to change the value in this ref\n */\nexport type RefChangeListener<T> = (\n  value: T | null,\n  prevValue: T | undefined,\n) => void | false;\n\n/**\n * Alternative to React.createRef but works in MobX world.\n * Typically it the should be the same React.LegacyRef (fn style)\n */\nexport interface Ref<T = any, TMeta = AnyObject> {\n  /**\n   * Setter function\n   */\n  (value: Maybe<T>): void;\n\n  set(value: Maybe<T>): void;\n  listeners: Set<RefChangeListener<NoInfer<T>>>;\n  current: NoInfer<T> | null;\n  meta: TMeta;\n}\n\nexport interface CreateRefConfig<T = any, TMeta = AnyObject> {\n  onSet?: (node: T, prevValue: T | undefined) => void;\n  onUnset?: (lastValue: T | undefined) => void;\n  onChange?: RefChangeListener<T>;\n  meta?: TMeta;\n  initial?: Maybe<T>;\n  comparer?: IEqualsComparer<T | null>;\n}\n\n/**\n * Creates a MobX-aware ref that behaves like a callback ref and exposes\n * observable `current` and `meta` fields.\n *\n * @template T Referenced value type.\n * @template TMeta Additional observable metadata stored on the ref.\n * @param cfg Optional callbacks, initial value and comparer configuration.\n * @returns Observable ref function object.\n *\n * @example\n * ```ts\n * const inputRef = createRef<HTMLInputElement>();\n * inputRef.set(document.createElement('input'));\n * ```\n *\n * @example\n * ```ts\n * const ref = createRef<number>();\n * ref(3);\n * ref.current; // 3\n * ```\n *\n * @example\n * ```ts\n * const nodeRef = createRef({\n *   onUnset: () => console.log('detached'),\n *   meta: { mounted: false },\n * });\n * ```\n */\nexport const createRef = <T = any, TMeta = AnyObject>(\n  cfg?: CreateRefConfig<T, TMeta>,\n): Ref<T, TMeta> => {\n  let lastValue: T | undefined;\n  const comparer = cfg?.comparer ?? mobxComparer.default;\n\n  const setValue: Ref<T, TMeta>['set'] = (value) => {\n    const nextValue = value ?? null;\n\n    if (comparer(ref.current, nextValue)) {\n      return;\n    }\n\n    runInAction(() => {\n      const prevLastValue = lastValue;\n      lastValue = ref.current ?? undefined;\n      ref.current = nextValue;\n\n      let isNextValueIgnored = false;\n\n      ref.listeners.forEach((listener) => {\n        const listenerResult = listener(ref.current, lastValue);\n\n        if (listenerResult === false) {\n          isNextValueIgnored = true;\n        }\n      });\n\n      if (isNextValueIgnored) {\n        lastValue = prevLastValue;\n        ref.current = lastValue ?? null;\n      } else if (ref.current === null && lastValue !== undefined) {\n        lastValue = undefined;\n      }\n    });\n  };\n\n  const ref = setValue as Ref<T, TMeta>;\n\n  ref.set = setValue;\n\n  ref.listeners = new Set(cfg?.onChange ? [cfg.onChange] : []);\n\n  if (cfg?.onSet || cfg?.onUnset) {\n    ref.listeners.add((value, prevValue) => {\n      if (value) {\n        cfg.onSet?.(value, prevValue);\n      } else {\n        cfg.onUnset?.(prevValue);\n      }\n    });\n  }\n\n  ref.current = cfg?.initial ?? null;\n  ref.meta = cfg?.meta ?? ({} as TMeta);\n\n  makeObservable(ref, {\n    current: observable.ref,\n    meta: observable,\n  });\n\n  return ref;\n};\n\n/**\n * Checks whether the provided value is a ref created by `createRef`.\n *\n * @template T Referenced value type.\n * @template TMeta Ref metadata type.\n * @param value Value to inspect.\n * @returns `true` when the value is a ref-like function with `current`.\n *\n * @example\n * ```ts\n * const ref = createRef<number>();\n * isRef(ref); // true\n * ```\n *\n * @example\n * ```ts\n * isRef({ current: 1 }); // false\n * ```\n */\nexport const isRef = <T, TMeta = any>(\n  value: T | Ref<T, TMeta>,\n): value is Ref<T, TMeta> => {\n  return typeof value === 'function' && 'current' in value;\n};\n\n/**\n * Normalizes a plain value or an existing ref into a `Ref` instance.\n *\n * @template T Referenced value type.\n * @template TMeta Ref metadata type.\n * @param value Existing ref or initial plain value.\n * @param cfg Optional ref configuration applied when a new ref is created.\n * @returns Existing ref or a newly created ref initialized with `value`.\n *\n * @example\n * ```ts\n * const ref = toRef(document.body);\n * ref.current === document.body;\n * ```\n *\n * @example\n * ```ts\n * const existingRef = createRef<number>();\n * const sameRef = toRef(existingRef);\n * ```\n */\nexport const toRef = <T, TMeta = any>(\n  value: T | Ref<T, TMeta>,\n  cfg?: Omit<CreateRefConfig<T, TMeta>, 'initial'>,\n): Ref<T, TMeta> => {\n  return isRef(value) ? value : createRef({ initial: value, ...cfg });\n};\n","/**\n * ---header-docs-section---\n * # yummies/mobx\n *\n * ## Description\n *\n * **Deep observable object** with structural `set` patches that reuse nested observables when keys\n * overlap. Helps store trees (forms, filters, entities) under MobX without wholesale replacement\n * and without manual `observable.map` wiring for every level.\n *\n * ## Usage\n *\n * ```ts\n * import { DeepObservableStruct } from \"yummies/mobx\";\n * ```\n */\n\nimport { action, makeObservable, observable } from 'mobx';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { AnyObject } from 'yummies/types';\n\n/**\n * Wraps a plain object into a deeply observable structure and allows\n * patch-like updates while preserving nested observable references where possible.\n *\n * @template TData Observable object shape.\n *\n * @example\n * ```ts\n * const state = new DeepObservableStruct({ user: { name: 'Ann' } });\n * state.set({ user: { name: 'Bob' } });\n * ```\n *\n * @example\n * ```ts\n * const state = new DeepObservableStruct({ filters: { active: true } });\n * state.set({ filters: { active: false, archived: true } });\n * ```\n */\nexport class DeepObservableStruct<TData extends AnyObject> {\n  data: TData;\n\n  constructor(data: TData) {\n    this.data = data;\n\n    makeObservable(this, {\n      data: observable.deep,\n      set: action,\n    });\n  }\n\n  set(newData: Partial<TData>) {\n    type StackItem = [key: string, currObservable: AnyObject, new: AnyObject];\n\n    const stack: StackItem[] = Object.keys(this.data).map((key) => [\n      key,\n      this.data,\n      newData,\n    ]);\n\n    let currentIndex = 0;\n    let stackLength = stack.length;\n\n    while (currentIndex < stackLength) {\n      const [key, currObservableData, newData] = stack[currentIndex];\n      const newValue = newData[key];\n      const currValue = currObservableData[key];\n\n      currentIndex++;\n\n      if (key in newData) {\n        if (typeGuard.isObject(newValue) && typeGuard.isObject(currValue)) {\n          const newValueKeys = Object.keys(newValue);\n\n          Object.keys(currValue).forEach((childKey) => {\n            if (!(childKey in newValue)) {\n              delete currObservableData[key][childKey];\n            }\n          });\n\n          newValueKeys.forEach((childKey) => {\n            const length = stack.push([\n              childKey,\n              currObservableData[key],\n              newValue,\n            ]);\n            stackLength = length;\n          });\n        } else if (newValue !== currValue) {\n          currObservableData[key] = newValue;\n        }\n      } else {\n        delete currObservableData[key];\n      }\n    }\n\n    Object.keys(newData).forEach((newDataKey) => {\n      if (!this.data[newDataKey]) {\n        // @ts-expect-error\n        this.data[newDataKey] = newData[newDataKey];\n      }\n    });\n  }\n}\n","/**\n * ---header-docs-section---\n * # yummies/mobx\n *\n * ## Description\n *\n * Typed access to MobX **internal administration** (`$mobx`) for advanced tooling, migration scripts,\n * or introspection. Prefer public MobX APIs in application code; reach for this when you must align\n * with library internals or patch behavior at the administration layer.\n *\n * ## Usage\n *\n * ```ts\n * import { getMobxAdministration } from \"yummies/mobx\";\n * ```\n */\n\nimport { $mobx, type AnnotationMapEntry } from 'mobx';\nimport type { AnyObject } from 'yummies/types';\n\ntype ObservableObjectAdministration = Parameters<\n  Exclude<AnnotationMapEntry, boolean>['make_']\n>[0];\n\n/**\n * Returns the internal MobX administration object associated with an observable target.\n *\n * @param context Observable object instance.\n * @returns MobX administration internals stored under `$mobx`.\n *\n * @example\n * ```ts\n * const admin = getMobxAdministration(store);\n * admin.name_;\n * ```\n *\n * @example\n * ```ts\n * const values = getMobxAdministration(formState).values_;\n * ```\n */\nexport const getMobxAdministration = (\n  context: AnyObject,\n): ObservableObjectAdministration => context[$mobx];\n","/**\n * ---header-docs-section---\n * # yummies/mobx\n *\n * ## Description\n *\n * **Lazy subscriptions** tied to MobX observation: start work when the first reaction observes\n * tracked keys, stop when nothing listens anymore (optionally after a delay). Ideal for polling,\n * WebSocket feeds, or expensive caches that should idle when the UI is not mounted.\n *\n * ## Usage\n *\n * ```ts\n * import { lazyObserve } from \"yummies/mobx\";\n * ```\n */\n\nimport { onBecomeObserved, onBecomeUnobserved } from 'mobx';\n\n/**\n * Starts side effects only while one or more MobX observables are being observed.\n *\n * When the first property becomes observed, `onStart` is called. When all tracked\n * properties become unobserved, `onEnd` is called with the value returned by\n * `onStart`. Cleanup can be delayed via `endDelay`.\n *\n * It uses MobX `onBecomeObserved` and `onBecomeUnobserved` hooks to perform\n * lazy subscription management.\n *\n * @template TMetaData Data returned from `onStart` and forwarded to `onEnd`.\n * @param config Configuration for tracked properties and lifecycle callbacks.\n * @returns Cleanup function that clears the tracked state and runs `onEnd`.\n *\n * @example\n * ```ts\n * const stop = lazyObserve({\n *   context: store,\n *   property: 'items',\n *   onStart: () => api.subscribe(),\n *   onEnd: (subscription) => subscription.unsubscribe(),\n * });\n * ```\n *\n * @example\n * ```ts\n * lazyObserve({\n *   property: [boxA, boxB],\n *   onStart: () => console.log('observed'),\n *   endDelay: 300,\n * });\n * ```\n */\nexport const lazyObserve = <TMetaData = void>({\n  context,\n  property,\n  onStart,\n  onEnd,\n  endDelay = false,\n}: {\n  context?: any;\n  property: any | any[];\n  onStart?: () => TMetaData;\n  onEnd?: (metaData: TMetaData, cleanupFn: VoidFunction) => void;\n  endDelay?: number | false;\n}) => {\n  let timeoutId: ReturnType<typeof setTimeout> | undefined;\n  let metaData: TMetaData | undefined;\n  const observingProps = new Set<string>();\n  const properties = Array.isArray(property) ? property : [property];\n\n  const cleanup = () => {\n    observingProps.clear();\n\n    if (endDelay === false) {\n      onEnd?.(metaData!, cleanup);\n      metaData = undefined;\n      return;\n    }\n\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n      timeoutId = undefined;\n    }\n\n    timeoutId = setTimeout(() => {\n      onEnd?.(metaData!, cleanup);\n      timeoutId = undefined;\n      metaData = undefined;\n    }, endDelay);\n  };\n\n  const start = (property: string) => {\n    const isAlreadyObserving = observingProps.size > 0;\n    observingProps.add(property);\n\n    if (isAlreadyObserving) {\n      return;\n    }\n\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n      timeoutId = undefined;\n    }\n\n    metaData = onStart?.();\n  };\n\n  const stop = (property: string) => {\n    const isAlreadyNotObserving = !observingProps.size;\n\n    observingProps.delete(property);\n\n    const isObserving = observingProps.size > 0;\n\n    if (isAlreadyNotObserving || isObserving) {\n      return;\n    }\n\n    cleanup();\n  };\n\n  properties.forEach((property) => {\n    if (context) {\n      onBecomeObserved(context, property, () => start(property));\n      onBecomeUnobserved(context, property, () => stop(property));\n    } else {\n      onBecomeObserved(property, () => start(property));\n      onBecomeUnobserved(property, () => stop(property));\n    }\n  });\n\n  return cleanup;\n};\n"],"mappings":"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"}

package/ms.cjs

@@ -1,14 +1,41 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const unitsToMs = {
-  ms: 1,
-  sec: 1e3,
-  min: 1e3 * 60,
-  hour: 1e3 * 60 * 60,
-  day: 1e3 * 60 * 60 * 24,
-  week: 1e3 * 60 * 60 * 24 * 7
+//#region src/ms.ts
+/**
+* ---header-docs-section---
+* # yummies/ms
+*
+* ## Description
+*
+* Converts human-friendly time units (seconds, minutes, hours, days, weeks) to **milliseconds** for
+* timers, animations, and `dayjs`-style math. The `unitsToMs` map is shared across the library so
+* delays and durations stay consistent instead of scattering `* 1000` literals through the code.
+*
+* ## Usage
+*
+* ```ts
+* import { ms } from "yummies/ms";
+* ```
+*/
+var unitsToMs = {
+	ms: 1,
+	sec: 1e3,
+	min: 1e3 * 60,
+	hour: 1e3 * 60 * 60,
+	day: 1e3 * 60 * 60 * 24,
+	week: 1e3 * 60 * 60 * 24 * 7
 };
-const ms = (value, unit = "ms") => value * unitsToMs[unit];
+/**
+* Converts a value in the specified unit to milliseconds.
+*
+* @example
+* ```ts
+* ms(1, 'min') // 60_000
+* ms(30, 'sec') // 30_000
+* ```
+*/
+var ms = (value, unit = "ms") => value * unitsToMs[unit];
+//#endregion
 exports.ms = ms;
 exports.unitsToMs = unitsToMs;
-//# sourceMappingURL=ms.cjs.map
+
+//# sourceMappingURL=ms.cjs.map

package/ms.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"ms.cjs","sources":["../src/ms.ts"],"sourcesContent":["export const unitsToMs = {\n  ms: 1,\n  sec: 1000,\n  min: 1000 * 60,\n  hour: 1000 * 60 * 60,\n  day: 1000 * 60 * 60 * 24,\n  week: 1000 * 60 * 60 * 24 * 7,\n} as const;\n\n/**\n * Converts a value in the specified unit to milliseconds.\n *\n * @example\n * ```ts\n * ms(1, 'min') // 60_000\n * ms(30, 'sec') // 30_000\n * ```\n */\nexport const ms = (value: number, unit: keyof typeof unitsToMs = 'ms') =>\n  value * unitsToMs[unit];\n"],"names":[],"mappings":";;AAAO,MAAM,YAAY;AAAA,EACvB,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,KAAK,MAAO;AAAA,EACZ,MAAM,MAAO,KAAK;AAAA,EAClB,KAAK,MAAO,KAAK,KAAK;AAAA,EACtB,MAAM,MAAO,KAAK,KAAK,KAAK;AAC9B;AAWO,MAAM,KAAK,CAAC,OAAe,OAA+B,SAC/D,QAAQ,UAAU,IAAI;;;"}
+{"version":3,"file":"ms.cjs","names":[],"sources":["../src/ms.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/ms\n *\n * ## Description\n *\n * Converts human-friendly time units (seconds, minutes, hours, days, weeks) to **milliseconds** for\n * timers, animations, and `dayjs`-style math. The `unitsToMs` map is shared across the library so\n * delays and durations stay consistent instead of scattering `* 1000` literals through the code.\n *\n * ## Usage\n *\n * ```ts\n * import { ms } from \"yummies/ms\";\n * ```\n */\n\nexport const unitsToMs = {\n  ms: 1,\n  sec: 1000,\n  min: 1000 * 60,\n  hour: 1000 * 60 * 60,\n  day: 1000 * 60 * 60 * 24,\n  week: 1000 * 60 * 60 * 24 * 7,\n} as const;\n\n/**\n * Converts a value in the specified unit to milliseconds.\n *\n * @example\n * ```ts\n * ms(1, 'min') // 60_000\n * ms(30, 'sec') // 30_000\n * ```\n */\nexport const ms = (value: number, unit: keyof typeof unitsToMs = 'ms') =>\n  value * unitsToMs[unit];\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,IAAa,YAAY;CACvB,IAAI;CACJ,KAAK;CACL,KAAK,MAAO;CACZ,MAAM,MAAO,KAAK;CAClB,KAAK,MAAO,KAAK,KAAK;CACtB,MAAM,MAAO,KAAK,KAAK,KAAK;CAC7B;;;;;;;;;;AAWD,IAAa,MAAM,OAAe,OAA+B,SAC/D,QAAQ,UAAU"}

package/ms.d.ts

@@ -1,3 +1,19 @@
+/**
+ * ---header-docs-section---
+ * # yummies/ms
+ *
+ * ## Description
+ *
+ * Converts human-friendly time units (seconds, minutes, hours, days, weeks) to **milliseconds** for
+ * timers, animations, and `dayjs`-style math. The `unitsToMs` map is shared across the library so
+ * delays and durations stay consistent instead of scattering `* 1000` literals through the code.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { ms } from "yummies/ms";
+ * ```
+ */
 declare const unitsToMs: {
     readonly ms: 1;
     readonly sec: 1000;

package/ms.js

@@ -1,14 +1,39 @@
-const unitsToMs = {
-  ms: 1,
-  sec: 1e3,
-  min: 1e3 * 60,
-  hour: 1e3 * 60 * 60,
-  day: 1e3 * 60 * 60 * 24,
-  week: 1e3 * 60 * 60 * 24 * 7
+//#region src/ms.ts
+/**
+* ---header-docs-section---
+* # yummies/ms
+*
+* ## Description
+*
+* Converts human-friendly time units (seconds, minutes, hours, days, weeks) to **milliseconds** for
+* timers, animations, and `dayjs`-style math. The `unitsToMs` map is shared across the library so
+* delays and durations stay consistent instead of scattering `* 1000` literals through the code.
+*
+* ## Usage
+*
+* ```ts
+* import { ms } from "yummies/ms";
+* ```
+*/
+var unitsToMs = {
+	ms: 1,
+	sec: 1e3,
+	min: 1e3 * 60,
+	hour: 1e3 * 60 * 60,
+	day: 1e3 * 60 * 60 * 24,
+	week: 1e3 * 60 * 60 * 24 * 7
 };
-const ms = (value, unit = "ms") => value * unitsToMs[unit];
-export {
-  ms,
-  unitsToMs
-};
-//# sourceMappingURL=ms.js.map
+/**
+* Converts a value in the specified unit to milliseconds.
+*
+* @example
+* ```ts
+* ms(1, 'min') // 60_000
+* ms(30, 'sec') // 30_000
+* ```
+*/
+var ms = (value, unit = "ms") => value * unitsToMs[unit];
+//#endregion
+export { ms, unitsToMs };
+
+//# sourceMappingURL=ms.js.map

package/ms.js.map

@@ -1 +1 @@
-{"version":3,"file":"ms.js","sources":["../src/ms.ts"],"sourcesContent":["export const unitsToMs = {\n  ms: 1,\n  sec: 1000,\n  min: 1000 * 60,\n  hour: 1000 * 60 * 60,\n  day: 1000 * 60 * 60 * 24,\n  week: 1000 * 60 * 60 * 24 * 7,\n} as const;\n\n/**\n * Converts a value in the specified unit to milliseconds.\n *\n * @example\n * ```ts\n * ms(1, 'min') // 60_000\n * ms(30, 'sec') // 30_000\n * ```\n */\nexport const ms = (value: number, unit: keyof typeof unitsToMs = 'ms') =>\n  value * unitsToMs[unit];\n"],"names":[],"mappings":"AAAO,MAAM,YAAY;AAAA,EACvB,IAAI;AAAA,EACJ,KAAK;AAAA,EACL,KAAK,MAAO;AAAA,EACZ,MAAM,MAAO,KAAK;AAAA,EAClB,KAAK,MAAO,KAAK,KAAK;AAAA,EACtB,MAAM,MAAO,KAAK,KAAK,KAAK;AAC9B;AAWO,MAAM,KAAK,CAAC,OAAe,OAA+B,SAC/D,QAAQ,UAAU,IAAI;"}
+{"version":3,"file":"ms.js","names":[],"sources":["../src/ms.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/ms\n *\n * ## Description\n *\n * Converts human-friendly time units (seconds, minutes, hours, days, weeks) to **milliseconds** for\n * timers, animations, and `dayjs`-style math. The `unitsToMs` map is shared across the library so\n * delays and durations stay consistent instead of scattering `* 1000` literals through the code.\n *\n * ## Usage\n *\n * ```ts\n * import { ms } from \"yummies/ms\";\n * ```\n */\n\nexport const unitsToMs = {\n  ms: 1,\n  sec: 1000,\n  min: 1000 * 60,\n  hour: 1000 * 60 * 60,\n  day: 1000 * 60 * 60 * 24,\n  week: 1000 * 60 * 60 * 24 * 7,\n} as const;\n\n/**\n * Converts a value in the specified unit to milliseconds.\n *\n * @example\n * ```ts\n * ms(1, 'min') // 60_000\n * ms(30, 'sec') // 30_000\n * ```\n */\nexport const ms = (value: number, unit: keyof typeof unitsToMs = 'ms') =>\n  value * unitsToMs[unit];\n"],"mappings":";;;;;;;;;;;;;;;;;AAiBA,IAAa,YAAY;CACvB,IAAI;CACJ,KAAK;CACL,KAAK,MAAO;CACZ,MAAM,MAAO,KAAK;CAClB,KAAK,MAAO,KAAK,KAAK;CACtB,MAAM,MAAO,KAAK,KAAK,KAAK;CAC7B;;;;;;;;;;AAWD,IAAa,MAAM,OAAe,OAA+B,SAC/D,QAAQ,UAAU"}

package/number.cjs

@@ -1,11 +1,33 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/number.ts
+/**
+* ---header-docs-section---
+* # yummies/number
+*
+* ## Description
+*
+* Numeric rounding that avoids classic floating-point artifacts (`191.212999…`) without paying for
+* string round-trips in hot paths. Use when formatting prices, charts, or sliders where a fixed
+* decimal count must be stable for display and comparisons.
+*
+* ## Usage
+*
+* ```ts
+* import { round } from "yummies/number";
+* ```
+*/
+/**
+* Works like `parseFloat(number.toFixed(4))` but performance better
+*
+* @example
+* round(191.212999999999999999999999, 4) // 191.213
+*/
 function round(value, decimalPlaces = 0) {
-  if (!decimalPlaces) {
-    return Math.round(value);
-  }
-  const factor = 10 ** decimalPlaces;
-  return Math.round(value * factor) / factor;
+	if (!decimalPlaces) return Math.round(value);
+	const factor = 10 ** decimalPlaces;
+	return Math.round(value * factor) / factor;
 }
+//#endregion
 exports.round = round;
-//# sourceMappingURL=number.cjs.map
+
+//# sourceMappingURL=number.cjs.map

package/number.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"number.cjs","sources":["../src/number.ts"],"sourcesContent":["/**\n * Works like `parseFloat(number.toFixed(4))` but performance better\n *\n * @example\n * round(191.212999999999999999999999, 4) // 191.213\n */\nexport function round(value: number, decimalPlaces: number = 0): number {\n  if (!decimalPlaces) {\n    return Math.round(value);\n  }\n\n  const factor = 10 ** decimalPlaces;\n  return Math.round(value * factor) / factor;\n}\n"],"names":[],"mappings":";;AAMO,SAAS,MAAM,OAAe,gBAAwB,GAAW;AACtE,MAAI,CAAC,eAAe;AAClB,WAAO,KAAK,MAAM,KAAK;AAAA,EACzB;AAEA,QAAM,SAAS,MAAM;AACrB,SAAO,KAAK,MAAM,QAAQ,MAAM,IAAI;AACtC;;"}
+{"version":3,"file":"number.cjs","names":[],"sources":["../src/number.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/number\n *\n * ## Description\n *\n * Numeric rounding that avoids classic floating-point artifacts (`191.212999…`) without paying for\n * string round-trips in hot paths. Use when formatting prices, charts, or sliders where a fixed\n * decimal count must be stable for display and comparisons.\n *\n * ## Usage\n *\n * ```ts\n * import { round } from \"yummies/number\";\n * ```\n */\n\n/**\n * Works like `parseFloat(number.toFixed(4))` but performance better\n *\n * @example\n * round(191.212999999999999999999999, 4) // 191.213\n */\nexport function round(value: number, decimalPlaces: number = 0): number {\n  if (!decimalPlaces) {\n    return Math.round(value);\n  }\n\n  const factor = 10 ** decimalPlaces;\n  return Math.round(value * factor) / factor;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,MAAM,OAAe,gBAAwB,GAAW;AACtE,KAAI,CAAC,cACH,QAAO,KAAK,MAAM,MAAM;CAG1B,MAAM,SAAS,MAAM;AACrB,QAAO,KAAK,MAAM,QAAQ,OAAO,GAAG"}

package/number.d.ts

@@ -1,3 +1,19 @@
+/**
+ * ---header-docs-section---
+ * # yummies/number
+ *
+ * ## Description
+ *
+ * Numeric rounding that avoids classic floating-point artifacts (`191.212999…`) without paying for
+ * string round-trips in hot paths. Use when formatting prices, charts, or sliders where a fixed
+ * decimal count must be stable for display and comparisons.
+ *
+ * ## Usage
+ *
+ * ```ts
+ * import { round } from "yummies/number";
+ * ```
+ */
 /**
  * Works like `parseFloat(number.toFixed(4))` but performance better
  *

package/number.js

@@ -1,11 +1,32 @@
+//#region src/number.ts
+/**
+* ---header-docs-section---
+* # yummies/number
+*
+* ## Description
+*
+* Numeric rounding that avoids classic floating-point artifacts (`191.212999…`) without paying for
+* string round-trips in hot paths. Use when formatting prices, charts, or sliders where a fixed
+* decimal count must be stable for display and comparisons.
+*
+* ## Usage
+*
+* ```ts
+* import { round } from "yummies/number";
+* ```
+*/
+/**
+* Works like `parseFloat(number.toFixed(4))` but performance better
+*
+* @example
+* round(191.212999999999999999999999, 4) // 191.213
+*/
 function round(value, decimalPlaces = 0) {
-  if (!decimalPlaces) {
-    return Math.round(value);
-  }
-  const factor = 10 ** decimalPlaces;
-  return Math.round(value * factor) / factor;
+	if (!decimalPlaces) return Math.round(value);
+	const factor = 10 ** decimalPlaces;
+	return Math.round(value * factor) / factor;
 }
-export {
-  round
-};
-//# sourceMappingURL=number.js.map
+//#endregion
+export { round };
+
+//# sourceMappingURL=number.js.map

package/number.js.map

@@ -1 +1 @@
-{"version":3,"file":"number.js","sources":["../src/number.ts"],"sourcesContent":["/**\n * Works like `parseFloat(number.toFixed(4))` but performance better\n *\n * @example\n * round(191.212999999999999999999999, 4) // 191.213\n */\nexport function round(value: number, decimalPlaces: number = 0): number {\n  if (!decimalPlaces) {\n    return Math.round(value);\n  }\n\n  const factor = 10 ** decimalPlaces;\n  return Math.round(value * factor) / factor;\n}\n"],"names":[],"mappings":"AAMO,SAAS,MAAM,OAAe,gBAAwB,GAAW;AACtE,MAAI,CAAC,eAAe;AAClB,WAAO,KAAK,MAAM,KAAK;AAAA,EACzB;AAEA,QAAM,SAAS,MAAM;AACrB,SAAO,KAAK,MAAM,QAAQ,MAAM,IAAI;AACtC;"}
+{"version":3,"file":"number.js","names":[],"sources":["../src/number.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/number\n *\n * ## Description\n *\n * Numeric rounding that avoids classic floating-point artifacts (`191.212999…`) without paying for\n * string round-trips in hot paths. Use when formatting prices, charts, or sliders where a fixed\n * decimal count must be stable for display and comparisons.\n *\n * ## Usage\n *\n * ```ts\n * import { round } from \"yummies/number\";\n * ```\n */\n\n/**\n * Works like `parseFloat(number.toFixed(4))` but performance better\n *\n * @example\n * round(191.212999999999999999999999, 4) // 191.213\n */\nexport function round(value: number, decimalPlaces: number = 0): number {\n  if (!decimalPlaces) {\n    return Math.round(value);\n  }\n\n  const factor = 10 ** decimalPlaces;\n  return Math.round(value * factor) / factor;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,MAAM,OAAe,gBAAwB,GAAW;AACtE,KAAI,CAAC,cACH,QAAO,KAAK,MAAM,MAAM;CAG1B,MAAM,SAAS,MAAM;AACrB,QAAO,KAAK,MAAM,QAAQ,OAAO,GAAG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yummies",
-  "version": "7.11.0",
+  "version": "7.13.0",
   "keywords": [
     "javascript",
     "typescript",
@@ -12,7 +12,7 @@
   "bugs": {
     "url": "https://github.com/js2me/yummies/issues"
   },
-  "homepage": "https://github.com/js2me/yummies",
+  "homepage": "https://js2me.github.io/yummies/api/async/",
   "repository": {
     "type": "git",
     "url": "git://github.com/js2me/yummies"
@@ -35,7 +35,7 @@
     "clsx": "^2.1.1",
     "dayjs": "^1.11.20",
     "dompurify": "^3.3.3",
-    "nanoid": "^5.1.6",
+    "nanoid": "^5.1.7",
     "tailwind-merge": "^3.5.0"
   },
   "type": "module",
@@ -46,6 +46,14 @@
       "require": "./async.cjs",
       "default": "./async.js"
     },
+    "./chunk-CVq3Gv4J": {
+      "require": "./chunk-CVq3Gv4J.cjs",
+      "default": "./chunk-CVq3Gv4J.cjs"
+    },
+    "./chunk-YKewjYmz": {
+      "import": "./chunk-YKewjYmz.js",
+      "default": "./chunk-YKewjYmz.js"
+    },
     "./common": {
       "types": "./common.d.ts",
       "import": "./common.js",

package/parser.cjs

@@ -1,69 +1,122 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const format = require("yummies/format");
-const typeGuard = require("yummies/type-guard");
-const number = (input, userSettings) => {
-  const settings = {
-    ...number.defaultSettings,
-    ...userSettings
-  };
-  const fallback = "fallback" in settings ? settings.fallback : 0;
-  let result;
-  if (typeGuard.typeGuard.isNumber(input)) {
-    result = input;
-  } else if (typeGuard.typeGuard.isString(input)) {
-    const formattedInput = format.format.skipSpaces(input).replace(",", ".");
-    if (formattedInput === "") {
-      result = fallback;
-    } else {
-      result = Number(formattedInput);
-    }
-  } else {
-    result = fallback;
-  }
-  if (typeGuard.typeGuard.isNumber(result)) {
-    if (settings?.clamped != null) {
-      result = Math.max(
-        settings.clamped[0] ?? -Infinity,
-        Math.min(result, settings.clamped[1] ?? Infinity)
-      );
-    }
-    if (settings?.ceil != null) {
-      result = Math.ceil(result);
-    }
-    if (settings?.floor != null) {
-      result = Math.floor(result);
-    }
-    if (settings?.digits != null) {
-      result = +result.toFixed(settings.digits);
-    }
-    return result;
-  } else {
-    return fallback;
-  }
+const require_chunk = require("./chunk-CVq3Gv4J.cjs");
+let yummies_type_guard = require("yummies/type-guard");
+let yummies_format = require("yummies/format");
+//#region src/parser/number.ts
+/**
+* Parses a number from raw input and optionally clamps, rounds or limits
+* fractional digits.
+*
+* Strings are normalized by removing spaces and replacing `,` with `.` before
+* parsing. Invalid inputs return the configured fallback.
+*
+* @template TFallback Fallback value type returned when parsing fails.
+* @param input Raw value to parse.
+* @param userSettings Parser settings merged with `number.defaultSettings`.
+* @returns Parsed number or fallback value.
+*
+* @example
+* ```ts
+* number('1 234,5'); // 1234.5
+* ```
+*
+* @example
+* ```ts
+* number('bad', { fallback: 0 }); // 0
+* ```
+*/
+var number = (input, userSettings) => {
+	const settings = {
+		...number.defaultSettings,
+		...userSettings
+	};
+	const fallback = "fallback" in settings ? settings.fallback : 0;
+	let result;
+	if (yummies_type_guard.typeGuard.isNumber(input)) result = input;
+	else if (yummies_type_guard.typeGuard.isString(input)) {
+		const formattedInput = yummies_format.format.skipSpaces(input).replace(",", ".");
+		if (formattedInput === "") result = fallback;
+		else result = Number(formattedInput);
+	} else result = fallback;
+	if (yummies_type_guard.typeGuard.isNumber(result)) {
+		if (settings?.clamped != null) result = Math.max(settings.clamped[0] ?? -Infinity, Math.min(result, settings.clamped[1] ?? Infinity));
+		if (settings?.ceil != null) result = Math.ceil(result);
+		if (settings?.floor != null) result = Math.floor(result);
+		if (settings?.digits != null) result = +result.toFixed(settings.digits);
+		return result;
+	} else return fallback;
 };
 number.defaultSettings = {};
-const percent = (value, maxValue, settings) => {
-  return number(Number(value) / Number(maxValue) * 100, settings);
+//#endregion
+//#region src/parser/percent.ts
+/**
+* Converts a value into a percentage of `maxValue` and parses the result with
+* the shared numeric parser.
+*
+* @template TFallback Fallback value type returned when parsing fails.
+* @param value Current value.
+* @param maxValue Maximum value representing `100%`.
+* @param settings Numeric parser settings for the computed percentage.
+* @returns Parsed percentage or fallback value.
+*
+* @example
+* ```ts
+* percent(25, 200); // 12.5
+* ```
+*
+* @example
+* ```ts
+* percent('bad', 100, { fallback: 0 }); // 0
+* ```
+*/
+var percent = (value, maxValue, settings) => {
+	return number(Number(value) / Number(maxValue) * 100, settings);
 };
-const string = (input, settings) => {
-  const fallback = settings && "fallback" in settings ? settings.fallback : "";
-  if (input == null) {
-    return fallback;
-  }
-  if (typeGuard.typeGuard.isObject(input)) {
-    if (settings?.prettyJson) {
-      return JSON.stringify(input, null, 2);
-    }
-    return JSON.stringify(input);
-  }
-  return String(input);
+//#endregion
+//#region src/parser/string.ts
+/**
+* Converts arbitrary input into a string representation.
+*
+* Objects are serialized with `JSON.stringify`, optionally pretty-printed, and
+* nullish values resolve to the configured fallback.
+*
+* @template TFallback Fallback value type returned for nullish input.
+* @param input Raw value to stringify.
+* @param settings String conversion settings.
+* @returns Stringified input or fallback value.
+*
+* @example
+* ```ts
+* string(123); // '123'
+* ```
+*
+* @example
+* ```ts
+* string({ id: 1 }, { prettyJson: true });
+* ```
+*/
+var string = (input, settings) => {
+	const fallback = settings && "fallback" in settings ? settings.fallback : "";
+	if (input == null) return fallback;
+	if (yummies_type_guard.typeGuard.isObject(input)) {
+		if (settings?.prettyJson) return JSON.stringify(input, null, 2);
+		return JSON.stringify(input);
+	}
+	return String(input);
 };
-const _exports = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  number,
-  percent,
-  string
-}, Symbol.toStringTag, { value: "Module" }));
-exports.parser = _exports;
-//# sourceMappingURL=parser.cjs.map
+//#endregion
+//#region src/parser/_exports.ts
+var _exports_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	number: () => number,
+	percent: () => percent,
+	string: () => string
+});
+//#endregion
+Object.defineProperty(exports, "parser", {
+	enumerable: true,
+	get: function() {
+		return _exports_exports;
+	}
+});
+
+//# sourceMappingURL=parser.cjs.map

package/parser.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"parser.cjs","sources":["../src/parser/number.ts","../src/parser/percent.ts","../src/parser/string.ts"],"sourcesContent":["import { format } from 'yummies/format';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { Maybe } from 'yummies/types';\n\nexport interface NumberParserSettings<TFallback = number> {\n  digits?: number;\n  fallback?: TFallback;\n  /**\n   * Round to upper boundary\n   * 5.1 -> 6\n   */\n  ceil?: boolean;\n  /**\n   * Round to bottom boundary\n   * 5.9 -> 5\n   */\n  floor?: boolean;\n  clamped?: [min?: Maybe<number>, max?: Maybe<number>];\n}\n\n/**\n * Parses a number from raw input and optionally clamps, rounds or limits\n * fractional digits.\n *\n * Strings are normalized by removing spaces and replacing `,` with `.` before\n * parsing. Invalid inputs return the configured fallback.\n *\n * @template TFallback Fallback value type returned when parsing fails.\n * @param input Raw value to parse.\n * @param userSettings Parser settings merged with `number.defaultSettings`.\n * @returns Parsed number or fallback value.\n *\n * @example\n * ```ts\n * number('1 234,5'); // 1234.5\n * ```\n *\n * @example\n * ```ts\n * number('bad', { fallback: 0 }); // 0\n * ```\n */\nexport const number = <TFallback = number>(\n  input: Maybe<unknown>,\n  userSettings?: Maybe<NumberParserSettings<TFallback>>,\n): number | TFallback => {\n  const settings = {\n    ...number.defaultSettings,\n    ...userSettings,\n  };\n\n  const fallback = (\n    'fallback' in settings ? settings.fallback : 0\n  ) as TFallback;\n\n  let result: number;\n\n  if (typeGuard.isNumber(input)) {\n    result = input;\n  } else if (typeGuard.isString(input)) {\n    const formattedInput = format.skipSpaces(input).replace(',', '.');\n    if (formattedInput === '') {\n      result = fallback as any;\n    } else {\n      result = Number(formattedInput);\n    }\n  } else {\n    result = fallback as any;\n  }\n\n  if (typeGuard.isNumber(result)) {\n    if (settings?.clamped != null) {\n      result = Math.max(\n        settings.clamped[0] ?? -Infinity,\n        Math.min(result, settings.clamped[1] ?? Infinity),\n      );\n    }\n\n    if (settings?.ceil != null) {\n      result = Math.ceil(result);\n    }\n\n    if (settings?.floor != null) {\n      result = Math.floor(result);\n    }\n\n    if (settings?.digits != null) {\n      result = +result.toFixed(settings.digits);\n    }\n\n    return result;\n  } else {\n    return fallback;\n  }\n};\n\nnumber.defaultSettings = {} as NumberParserSettings;\n","import type { Maybe } from 'yummies/types';\n\nimport { type NumberParserSettings, number } from './number.js';\n\n/**\n * Converts a value into a percentage of `maxValue` and parses the result with\n * the shared numeric parser.\n *\n * @template TFallback Fallback value type returned when parsing fails.\n * @param value Current value.\n * @param maxValue Maximum value representing `100%`.\n * @param settings Numeric parser settings for the computed percentage.\n * @returns Parsed percentage or fallback value.\n *\n * @example\n * ```ts\n * percent(25, 200); // 12.5\n * ```\n *\n * @example\n * ```ts\n * percent('bad', 100, { fallback: 0 }); // 0\n * ```\n */\nexport const percent = <TFallback = number>(\n  value: Maybe<string | number>,\n  maxValue?: Maybe<string | number>,\n  settings?: Maybe<NumberParserSettings<TFallback>>,\n) => {\n  return number<TFallback>((Number(value) / Number(maxValue)) * 100, settings);\n};\n","import { typeGuard } from 'yummies/type-guard';\nimport type { Maybe } from 'yummies/types';\n\nexport interface StringParserSettings<TFallback = string> {\n  fallback?: TFallback;\n  prettyJson?: boolean;\n}\n\n/**\n * Converts arbitrary input into a string representation.\n *\n * Objects are serialized with `JSON.stringify`, optionally pretty-printed, and\n * nullish values resolve to the configured fallback.\n *\n * @template TFallback Fallback value type returned for nullish input.\n * @param input Raw value to stringify.\n * @param settings String conversion settings.\n * @returns Stringified input or fallback value.\n *\n * @example\n * ```ts\n * string(123); // '123'\n * ```\n *\n * @example\n * ```ts\n * string({ id: 1 }, { prettyJson: true });\n * ```\n */\nexport const string = <TFallback = string>(\n  input: Maybe<unknown>,\n  settings?: Maybe<StringParserSettings<TFallback>>,\n): string | TFallback => {\n  const fallback =\n    settings && 'fallback' in settings ? (settings.fallback as TFallback) : '';\n\n  if (input == null) {\n    return fallback;\n  }\n\n  if (typeGuard.isObject(input)) {\n    if (settings?.prettyJson) {\n      return JSON.stringify(input, null, 2);\n    }\n\n    return JSON.stringify(input);\n  }\n\n  return String(input);\n};\n"],"names":["typeGuard","format"],"mappings":";;;;AA0CO,MAAM,SAAS,CACpB,OACA,iBACuB;AACvB,QAAM,WAAW;AAAA,IACf,GAAG,OAAO;AAAA,IACV,GAAG;AAAA,EAAA;AAGL,QAAM,WACJ,cAAc,WAAW,SAAS,WAAW;AAG/C,MAAI;AAEJ,MAAIA,UAAAA,UAAU,SAAS,KAAK,GAAG;AAC7B,aAAS;AAAA,EACX,WAAWA,UAAAA,UAAU,SAAS,KAAK,GAAG;AACpC,UAAM,iBAAiBC,OAAAA,OAAO,WAAW,KAAK,EAAE,QAAQ,KAAK,GAAG;AAChE,QAAI,mBAAmB,IAAI;AACzB,eAAS;AAAA,IACX,OAAO;AACL,eAAS,OAAO,cAAc;AAAA,IAChC;AAAA,EACF,OAAO;AACL,aAAS;AAAA,EACX;AAEA,MAAID,UAAAA,UAAU,SAAS,MAAM,GAAG;AAC9B,QAAI,UAAU,WAAW,MAAM;AAC7B,eAAS,KAAK;AAAA,QACZ,SAAS,QAAQ,CAAC,KAAK;AAAA,QACvB,KAAK,IAAI,QAAQ,SAAS,QAAQ,CAAC,KAAK,QAAQ;AAAA,MAAA;AAAA,IAEpD;AAEA,QAAI,UAAU,QAAQ,MAAM;AAC1B,eAAS,KAAK,KAAK,MAAM;AAAA,IAC3B;AAEA,QAAI,UAAU,SAAS,MAAM;AAC3B,eAAS,KAAK,MAAM,MAAM;AAAA,IAC5B;AAEA,QAAI,UAAU,UAAU,MAAM;AAC5B,eAAS,CAAC,OAAO,QAAQ,SAAS,MAAM;AAAA,IAC1C;AAEA,WAAO;AAAA,EACT,OAAO;AACL,WAAO;AAAA,EACT;AACF;AAEA,OAAO,kBAAkB,CAAA;ACxElB,MAAM,UAAU,CACrB,OACA,UACA,aACG;AACH,SAAO,OAAmB,OAAO,KAAK,IAAI,OAAO,QAAQ,IAAK,KAAK,QAAQ;AAC7E;ACDO,MAAM,SAAS,CACpB,OACA,aACuB;AACvB,QAAM,WACJ,YAAY,cAAc,WAAY,SAAS,WAAyB;AAE1E,MAAI,SAAS,MAAM;AACjB,WAAO;AAAA,EACT;AAEA,MAAIA,UAAAA,UAAU,SAAS,KAAK,GAAG;AAC7B,QAAI,UAAU,YAAY;AACxB,aAAO,KAAK,UAAU,OAAO,MAAM,CAAC;AAAA,IACtC;AAEA,WAAO,KAAK,UAAU,KAAK;AAAA,EAC7B;AAEA,SAAO,OAAO,KAAK;AACrB;;;;;;;;"}
+{"version":3,"file":"parser.cjs","names":[],"sources":["../src/parser/number.ts","../src/parser/percent.ts","../src/parser/string.ts","../src/parser/_exports.ts"],"sourcesContent":["import { format } from 'yummies/format';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { Maybe } from 'yummies/types';\n\nexport interface NumberParserSettings<TFallback = number> {\n  digits?: number;\n  fallback?: TFallback;\n  /**\n   * Round to upper boundary\n   * 5.1 -> 6\n   */\n  ceil?: boolean;\n  /**\n   * Round to bottom boundary\n   * 5.9 -> 5\n   */\n  floor?: boolean;\n  clamped?: [min?: Maybe<number>, max?: Maybe<number>];\n}\n\n/**\n * Parses a number from raw input and optionally clamps, rounds or limits\n * fractional digits.\n *\n * Strings are normalized by removing spaces and replacing `,` with `.` before\n * parsing. Invalid inputs return the configured fallback.\n *\n * @template TFallback Fallback value type returned when parsing fails.\n * @param input Raw value to parse.\n * @param userSettings Parser settings merged with `number.defaultSettings`.\n * @returns Parsed number or fallback value.\n *\n * @example\n * ```ts\n * number('1 234,5'); // 1234.5\n * ```\n *\n * @example\n * ```ts\n * number('bad', { fallback: 0 }); // 0\n * ```\n */\nexport const number = <TFallback = number>(\n  input: Maybe<unknown>,\n  userSettings?: Maybe<NumberParserSettings<TFallback>>,\n): number | TFallback => {\n  const settings = {\n    ...number.defaultSettings,\n    ...userSettings,\n  };\n\n  const fallback = (\n    'fallback' in settings ? settings.fallback : 0\n  ) as TFallback;\n\n  let result: number;\n\n  if (typeGuard.isNumber(input)) {\n    result = input;\n  } else if (typeGuard.isString(input)) {\n    const formattedInput = format.skipSpaces(input).replace(',', '.');\n    if (formattedInput === '') {\n      result = fallback as any;\n    } else {\n      result = Number(formattedInput);\n    }\n  } else {\n    result = fallback as any;\n  }\n\n  if (typeGuard.isNumber(result)) {\n    if (settings?.clamped != null) {\n      result = Math.max(\n        settings.clamped[0] ?? -Infinity,\n        Math.min(result, settings.clamped[1] ?? Infinity),\n      );\n    }\n\n    if (settings?.ceil != null) {\n      result = Math.ceil(result);\n    }\n\n    if (settings?.floor != null) {\n      result = Math.floor(result);\n    }\n\n    if (settings?.digits != null) {\n      result = +result.toFixed(settings.digits);\n    }\n\n    return result;\n  } else {\n    return fallback;\n  }\n};\n\nnumber.defaultSettings = {} as NumberParserSettings;\n","import type { Maybe } from 'yummies/types';\n\nimport { type NumberParserSettings, number } from './number.js';\n\n/**\n * Converts a value into a percentage of `maxValue` and parses the result with\n * the shared numeric parser.\n *\n * @template TFallback Fallback value type returned when parsing fails.\n * @param value Current value.\n * @param maxValue Maximum value representing `100%`.\n * @param settings Numeric parser settings for the computed percentage.\n * @returns Parsed percentage or fallback value.\n *\n * @example\n * ```ts\n * percent(25, 200); // 12.5\n * ```\n *\n * @example\n * ```ts\n * percent('bad', 100, { fallback: 0 }); // 0\n * ```\n */\nexport const percent = <TFallback = number>(\n  value: Maybe<string | number>,\n  maxValue?: Maybe<string | number>,\n  settings?: Maybe<NumberParserSettings<TFallback>>,\n) => {\n  return number<TFallback>((Number(value) / Number(maxValue)) * 100, settings);\n};\n","import { typeGuard } from 'yummies/type-guard';\nimport type { Maybe } from 'yummies/types';\n\nexport interface StringParserSettings<TFallback = string> {\n  fallback?: TFallback;\n  prettyJson?: boolean;\n}\n\n/**\n * Converts arbitrary input into a string representation.\n *\n * Objects are serialized with `JSON.stringify`, optionally pretty-printed, and\n * nullish values resolve to the configured fallback.\n *\n * @template TFallback Fallback value type returned for nullish input.\n * @param input Raw value to stringify.\n * @param settings String conversion settings.\n * @returns Stringified input or fallback value.\n *\n * @example\n * ```ts\n * string(123); // '123'\n * ```\n *\n * @example\n * ```ts\n * string({ id: 1 }, { prettyJson: true });\n * ```\n */\nexport const string = <TFallback = string>(\n  input: Maybe<unknown>,\n  settings?: Maybe<StringParserSettings<TFallback>>,\n): string | TFallback => {\n  const fallback =\n    settings && 'fallback' in settings ? (settings.fallback as TFallback) : '';\n\n  if (input == null) {\n    return fallback;\n  }\n\n  if (typeGuard.isObject(input)) {\n    if (settings?.prettyJson) {\n      return JSON.stringify(input, null, 2);\n    }\n\n    return JSON.stringify(input);\n  }\n\n  return String(input);\n};\n","/**\n * ---header-docs-section---\n * # yummies/parser\n *\n * ## Description\n *\n * Parsers for user-entered **numbers, percents, and strings** with tolerant input and typed\n * results. Use when normalizing form values, query params, or CSV-like text before validation\n * schemas run, without duplicating regex and `parseFloat` edge cases in every feature module.\n *\n * ## Usage\n *\n * ```ts\n * import { parser } from \"yummies/parser\";\n * ```\n */\n\nexport * from './number.js';\nexport * from './percent.js';\nexport * from './string.js';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,UACX,OACA,iBACuB;CACvB,MAAM,WAAW;EACf,GAAG,OAAO;EACV,GAAG;EACJ;CAED,MAAM,WACJ,cAAc,WAAW,SAAS,WAAW;CAG/C,IAAI;AAEJ,KAAI,mBAAA,UAAU,SAAS,MAAM,CAC3B,UAAS;UACA,mBAAA,UAAU,SAAS,MAAM,EAAE;EACpC,MAAM,iBAAiB,eAAA,OAAO,WAAW,MAAM,CAAC,QAAQ,KAAK,IAAI;AACjE,MAAI,mBAAmB,GACrB,UAAS;MAET,UAAS,OAAO,eAAe;OAGjC,UAAS;AAGX,KAAI,mBAAA,UAAU,SAAS,OAAO,EAAE;AAC9B,MAAI,UAAU,WAAW,KACvB,UAAS,KAAK,IACZ,SAAS,QAAQ,MAAM,WACvB,KAAK,IAAI,QAAQ,SAAS,QAAQ,MAAM,SAAS,CAClD;AAGH,MAAI,UAAU,QAAQ,KACpB,UAAS,KAAK,KAAK,OAAO;AAG5B,MAAI,UAAU,SAAS,KACrB,UAAS,KAAK,MAAM,OAAO;AAG7B,MAAI,UAAU,UAAU,KACtB,UAAS,CAAC,OAAO,QAAQ,SAAS,OAAO;AAG3C,SAAO;OAEP,QAAO;;AAIX,OAAO,kBAAkB,EAAE;;;;;;;;;;;;;;;;;;;;;;;ACxE3B,IAAa,WACX,OACA,UACA,aACG;AACH,QAAO,OAAmB,OAAO,MAAM,GAAG,OAAO,SAAS,GAAI,KAAK,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;ACA9E,IAAa,UACX,OACA,aACuB;CACvB,MAAM,WACJ,YAAY,cAAc,WAAY,SAAS,WAAyB;AAE1E,KAAI,SAAS,KACX,QAAO;AAGT,KAAI,mBAAA,UAAU,SAAS,MAAM,EAAE;AAC7B,MAAI,UAAU,WACZ,QAAO,KAAK,UAAU,OAAO,MAAM,EAAE;AAGvC,SAAO,KAAK,UAAU,MAAM;;AAG9B,QAAO,OAAO,MAAM"}