{"version":3,"sources":["../index.ts","../cookie-storage/helpers/is-enabled/index.ts","../cookie-storage/helpers/format-cookie-options/index.ts","../cookie-storage/functions/set-cookie-value/index.ts","../cookie-storage/functions/remove-cookie-value/index.ts","../cookie-storage/functions/clear-cookie-storage/index.ts","../cookie-storage/helpers/create-custom-word-pattern/index.ts","../cookie-storage/helpers/join/index.ts","../cookie-storage/helpers/transform-case/index.ts","../cookie-storage/functions/create-cookie-key/index.ts","../cookie-storage/functions/get-cookie-by-index/index.ts","../cookie-storage/functions/get-cookie-storage-length/index.ts","../cookie-storage/functions/get-cookie-value/index.ts","../cookie-storage/helpers/create-hmac/index.ts","../cookie-storage/functions/sign-cookie/index.ts","../cookie-storage/helpers/constant-time-compare/index.ts","../cookie-storage/functions/unsign-cookie/index.ts","../cookie-storage/index.ts","../create-store/functions/assertions/is-dictionary/index.ts","../create-store/functions/assertions/is-promise/index.ts","../create-store/functions/library/create-composite-store/index.ts","../create-store/functions/assertions/is-accessor/index.ts","../create-store/functions/assertions/is-function/index.ts","../create-store/functions/assertions/is-set-state-action-function/index.ts","../node_modules/.pnpm/@ibnlanre+clone@0.5.1/node_modules/@ibnlanre/clone/index.ts","../create-store/functions/helpers/clone/index.ts","../create-store/functions/helpers/create-path-components/index.ts","../create-store/functions/helpers/create-paths/index.ts","../create-store/functions/assertions/is-primitive/index.ts","../create-store/functions/assertions/is-dictionary-slice/index.ts","../create-store/functions/helpers/combine/index.ts","../create-store/functions/helpers/replace/index.ts","../create-store/functions/helpers/split-path/index.ts","../create-store/functions/hooks/use-sync/index.ts","../create-store/functions/hooks/use-version/index.ts","../create-store/functions/helpers/sort/index.ts","../create-store/functions/helpers/stringify/index.ts","../create-store/functions/helpers/compare/index.ts","../create-store/functions/utilities/resolve-path/index.ts","../create-store/functions/utilities/resolve-selector-value/index.ts","../create-store/functions/library/create-primitive-store/index.ts","../create-store/functions/utilities/resolve-value/index.ts","../create-store/index.ts","../create-store/functions/assertions/is-nullish/index.ts","../create-store/functions/adapters/create-async-browser-storage-adapter/index.ts","../create-store/functions/utilities/safe-stringify/index.ts","../create-store/functions/utilities/try-parse/index.ts","../create-store/functions/adapters/create-browser-storage-adapter/index.ts","../create-store/functions/helpers/merge/index.ts","../create-store/functions/adapters/create-cookie-storage-adapter/index.ts","../create-store/functions/adapters/create-local-storage-adapter/index.ts","../create-store/functions/adapters/create-session-storage-adapter/index.ts","../create-store/functions/hooks/use-async/index.ts","../create-store/functions/hooks/use-async/reducer.ts","../create-store/functions/library/create-context-store/index.tsx","../create-store/functions/assertions/is-object/index.ts","../create-store/functions/library/normalize-object/index.ts"],"sourcesContent":["export type { CookieOptions } from \"@/cookie-storage/types/cookie-options\";\nexport type { CookieStorage } from \"@/cookie-storage/types/cookie-storage\";\nexport type { CreateCookieKeyOptions } from \"@/cookie-storage/types/create-cookie-key-options\";\nexport type { WordMappingSegments } from \"@/cookie-storage/types/word-mapping-segments\";\nexport type {\n  AsyncBrowserStorageAdapterOptions,\n  AsyncBrowserStorageTransforms,\n  AsyncGetBrowserStorage,\n  AsyncSetBrowserStorage,\n} from \"@/create-store/types/async-browser-storage-adapter\";\nexport type { AsyncFunction } from \"@/create-store/types/async-function\";\nexport type { AsyncState } from \"@/create-store/types/async-state\";\nexport type {\n  BrowserStorageAdapterOptions,\n  GetBrowserStorage,\n  SetBrowserStorage,\n} from \"@/create-store/types/browser-storage-adapter\";\nexport type { Combine } from \"@/create-store/types/combine\";\nexport type { CompositeStore } from \"@/create-store/types/composite-store\";\nexport type { ContextStore } from \"@/create-store/types/context-store\";\nexport type { ContextValue } from \"@/create-store/types/context-value\";\nexport type {\n  CookieStorageAdapterOptions,\n  GetCookieStorage,\n  SetCookieStorage,\n} from \"@/create-store/types/cookie-storage\";\nexport type { DeepPartial } from \"@/create-store/types/deep-partial\";\nexport type { Dictionary } from \"@/create-store/types/dictionary\";\nexport type { Factory } from \"@/create-store/types/factory\";\nexport type { InferType } from \"@/create-store/types/infer-type\";\nexport type { Initializer } from \"@/create-store/types/initializer\";\nexport type {\n  GetLocalStorage,\n  SetLocalStorage,\n} from \"@/create-store/types/local-storage\";\nexport type { Normalize } from \"@/create-store/types/normalize\";\nexport type { PartialStateManager } from \"@/create-store/types/partial-state-manager\";\nexport type { PartialStateSetter } from \"@/create-store/types/partial-state-setter\";\nexport type { Paths } from \"@/create-store/types/paths\";\nexport type { PrimitiveStore } from \"@/create-store/types/primitive-store\";\nexport type { Replace } from \"@/create-store/types/replace\";\nexport type { ResolvePath } from \"@/create-store/types/resolve-path\";\nexport type { Selector } from \"@/create-store/types/selector\";\nexport type {\n  GetSessionStorage,\n  SetSessionStorage,\n} from \"@/create-store/types/session-storage\";\nexport type { SetPartial } from \"@/create-store/types/set-partial\";\nexport type { SetPartialStateAction } from \"@/create-store/types/set-partial-state-action\";\nexport type { StatePath } from \"@/create-store/types/state-path\";\nexport type { StorageAdapterOptions } from \"@/create-store/types/storage-adapter\";\nexport type { StoreValueResolver } from \"@/create-store/types/store-value-resolver\";\nexport type { Subscriber } from \"@/create-store/types/subscriber\";\n\nexport { cookieStorage } from \"@/cookie-storage\";\nexport { createStore } from \"@/create-store\";\nexport { createAsyncBrowserStorageAdapter } from \"@/create-store/functions/adapters/create-async-browser-storage-adapter\";\nexport { createBrowserStorageAdapter } from \"@/create-store/functions/adapters/create-browser-storage-adapter\";\nexport { createCookieStorageAdapter } from \"@/create-store/functions/adapters/create-cookie-storage-adapter\";\nexport { createLocalStorageAdapter } from \"@/create-store/functions/adapters/create-local-storage-adapter\";\nexport { createSessionStorageAdapter } from \"@/create-store/functions/adapters/create-session-storage-adapter\";\nexport { combine } from \"@/create-store/functions/helpers/combine\";\nexport { useAsync } from \"@/create-store/functions/hooks/use-async\";\nexport { useSync } from \"@/create-store/functions/hooks/use-sync\";\nexport { useVersion } from \"@/create-store/functions/hooks/use-version\";\nexport { createCompositeStore } from \"@/create-store/functions/library/create-composite-store\";\nexport { createContextStore } from \"@/create-store/functions/library/create-context-store\";\nexport { createPrimitiveStore } from \"@/create-store/functions/library/create-primitive-store\";\nexport { normalizeObject } from \"@/create-store/functions/library/normalize-object\";\n","export function isEnabled<Value>(\n  value: Value\n): value is Exclude<Value, false | null | undefined> {\n  return value !== null && value !== undefined && value !== false;\n}\n","import type { CookieOptions } from \"@/cookie-storage/types/cookie-options\";\n\nimport { isEnabled } from \"@/cookie-storage/helpers/is-enabled\";\n\n/**\n * Formats the provided cookie options into a string format compatible with the document.cookie API.\n *\n * @param {CookieOptions} [options] The cookie options to format.\n * @returns {string} The formatted cookie options as a string.\n */\nexport function formatCookieOptions({\n  path = \"/\",\n  ...options\n}: CookieOptions = {}): string {\n  let cookieOptions = `; path=${path}`;\n\n  const { domain, expires, httpOnly, maxAge, partitioned, sameSite, secure } = {\n    ...options,\n  };\n\n  if (isEnabled(domain)) cookieOptions += `; domain=${domain}`;\n  if (isEnabled(secure)) cookieOptions += \"; secure\";\n  if (isEnabled(httpOnly)) cookieOptions += \"; httpOnly\";\n  if (isEnabled(expires)) {\n    const expiresDate = new Date(expires).toUTCString();\n    cookieOptions += `; expires=${expiresDate}`;\n  }\n  if (isEnabled(sameSite)) cookieOptions += `; SameSite=${sameSite}`;\n  if (isEnabled(maxAge)) cookieOptions += `; max-age=${maxAge}`;\n  if (isEnabled(partitioned)) cookieOptions += \"; partitioned\";\n\n  return cookieOptions;\n}\n","import type { CookieOptions } from \"@/cookie-storage/types/cookie-options\";\n\nimport { formatCookieOptions } from \"@/cookie-storage/helpers/format-cookie-options\";\n\n/**\n * Sets a cookie with the specified name and value.\n *\n * @param {string} name The name of the cookie.\n * @param {string} value The value to be set for the cookie.\n * @param {CookieOptions} [options] Optional cookie options.\n *\n * @returns {void}\n */\nexport function setCookieValue(\n  name: string,\n  value: string,\n  options?: CookieOptions\n) {\n  try {\n    if (typeof document === \"undefined\") return;\n\n    const cookieOptionsString = formatCookieOptions(options);\n    document.cookie = `${name}=${value}${cookieOptionsString}`;\n  } catch (error) {\n    console.error(\"Error occurred while setting cookie:\", error);\n  }\n}\n","import { setCookieValue } from \"@/cookie-storage/functions/set-cookie-value\";\n\n/**\n * Removes a cookie with the specified name.\n *\n * @param {string} name The name of the cookie to be removed.\n * @param {string} [path] Optional path of the cookie to be removed.\n *\n * @returns {void}\n */\nexport function removeCookieValue(name: string, path = \"/\") {\n  try {\n    if (typeof document === \"undefined\") return;\n\n    setCookieValue(name, \"\", { expires: 0, path });\n  } catch (error) {\n    console.error(\"Error occurred while removing cookie\", error);\n  }\n}\n","import { removeCookieValue } from \"@/cookie-storage/functions/remove-cookie-value\";\n\n/**\n * Clears all cookies from cookieStorage.\n * @returns {void}\n */\nexport function clearCookieStorage() {\n  try {\n    if (typeof document === \"undefined\") return;\n\n    const cookies = document.cookie.split(\";\");\n    cookies.forEach((cookie) => {\n      const [name] = cookie.split(\"=\");\n      if (name) removeCookieValue(name.trim());\n    });\n  } catch (error) {\n    console.error(\"Error occurred while clearing cookieStorage:\", error);\n  }\n}\n","export function createCustomWordPattern(word: string, length: number): string {\n  if (!word) return \"\";\n  if (length < 0) throw new Error(\"Length must be a positive number\");\n  if (length >= word.length) return word;\n  if (length === 1) return word[0];\n\n  let consonants: number[] = [];\n  let vowels: number[] = [];\n\n  const vowelsLookup = new Set([\"a\", \"e\", \"i\", \"o\", \"u\"]);\n  const letters = Array.from({ length: word.length }, () => \"\");\n  const words = word.split(\"\");\n\n  words.forEach((char, index) => {\n    if (vowelsLookup.has(char)) vowels.push(index);\n    else consonants.push(index);\n  });\n\n  letters[0] = words[0];\n\n  let iterator = 0;\n  let index = iterator;\n\n  while (consonants.length) {\n    if (letters.filter(Boolean).length === length) break;\n    const character = words[index];\n\n    if (vowelsLookup.has(character)) {\n      if (index + 1 < word.length) index++;\n      else index = ++iterator;\n      continue;\n    }\n\n    letters[index] = character;\n    consonants = consonants.filter((idx) => idx !== index);\n    const factor = 2 - (iterator % 2);\n\n    if (index + factor === word.length) index++;\n    else if (index + factor < word.length) index += factor;\n    else index = ++iterator;\n  }\n\n  iterator = words.length - 1;\n  index = iterator;\n\n  while (vowels.length) {\n    if (letters.filter(Boolean).length === length) break;\n    const character = words[index];\n\n    letters[index] = character;\n    vowels = vowels.filter((idx) => idx !== index);\n    const factor = 2 + (iterator % 2);\n\n    if (index - factor === 0) index--;\n    else if (index - factor > 0) index -= factor;\n    else index = --iterator;\n  }\n\n  return letters.filter(Boolean).join(\"\");\n}\n","export function join(segments: string[], connector = \"\"): string {\n  return segments.filter(Boolean).join(connector);\n}\n","import type { CaseType } from \"@/cookie-storage/types/case-type\";\n\nexport function transformCase(text: string, caseType?: CaseType): string {\n  switch (caseType) {\n    case \"camel\":\n      return text\n        .toLowerCase()\n        .replace(/[-_ ](.)/g, (_, char) => char.toUpperCase())\n        .replace(/^[A-Z]/, (char) => char.toLowerCase());\n    case \"kebab\":\n      return text\n        .toLowerCase()\n        .replace(/\\s+/g, \"-\")\n        .replace(/[_]/g, \"-\")\n        .replace(/-+/g, \"-\");\n    case \"lower\":\n      return text.toLowerCase();\n    case \"pascal\":\n      return text\n        .toLowerCase()\n        .replace(/(?:^|\\s+|[-_])(.)/g, (_, char) => char.toUpperCase())\n        .replace(/[-_ ]/g, \"\");\n    case \"sentence\":\n      return text.toLowerCase().replace(/^[a-z]/, (char) => char.toUpperCase());\n    case \"title\":\n      return text.replace(/\\b\\w/g, (char) => char.toUpperCase());\n    case \"upper\":\n      return text.toUpperCase();\n    default:\n      return text.toLowerCase();\n  }\n}\n","import type { CreateCookieKeyOptions } from \"@/cookie-storage/types/create-cookie-key-options\";\n\nimport { createCustomWordPattern } from \"@/cookie-storage/helpers/create-custom-word-pattern\";\nimport { join } from \"@/cookie-storage/helpers/join\";\nimport { transformCase } from \"@/cookie-storage/helpers/transform-case\";\n\n/**\n * Creates a cookie key based on the provided options.\n *\n * @param options The options to use when generating the cookie key.\n * @returns The generated cookie key.\n *\n * @example\n *\n * ```ts\n * // __Secure-auth_vr-sgt\n *\n * createCookieKey({\n *  cookieFragmentDescription: \"Verification Signature\",\n *  cookiePrefix: \"__\",\n *  cookieFragmentSizes: [2, 3],\n *  cookieScope: \"secure\",\n *  cookieScopeCase: \"title\",\n *  cookieService: \"auth\",\n *  cookieScopeServiceConnector: \"-\",\n *  cookieScopeFragmentConnector: \"_\",\n *  cookieFragmentsConnector: \"-\",\n *  cookieSuffix: \"\",\n * });\n */\nexport function createCookieKey<CookieFragmentDescription extends string>({\n  cookieFragmentDescription,\n  cookieFragmentsConnector = \"\",\n  cookieFragmentSizes = [],\n  cookiePrefix = \"\",\n  cookieScope = \"\",\n  cookieScopeCase = \"title\",\n  cookieScopeFragmentConnector = \"_\",\n  cookieScopeServiceConnector = \"-\",\n  cookieService = \"\",\n  cookieSuffix = \"\",\n}: CreateCookieKeyOptions<CookieFragmentDescription>): string {\n  const words = cookieFragmentDescription.toLowerCase().split(\" \");\n\n  if (cookieFragmentSizes.length > words.length) {\n    throw new Error(\n      \"The number of fragments must be less than or equal to the number of words\"\n    );\n  }\n\n  if (cookieFragmentSizes.some((size) => size < 0)) {\n    throw new Error(\"Each fragment must be a positive number\");\n  }\n\n  const fragments = words.map((word, index) => {\n    const length = cookieFragmentSizes[index] ?? 1;\n    return createCustomWordPattern(word, length);\n  });\n\n  cookieScope = transformCase(cookieScope, cookieScopeCase);\n\n  const scope = join([cookiePrefix, cookieScope]);\n  const service = join([scope, cookieService], cookieScopeServiceConnector);\n  const description = join(fragments, cookieFragmentsConnector);\n  const name = join([service, description], cookieScopeFragmentConnector);\n\n  return join([name, cookieSuffix]);\n}\n","/**\n * Get a cookie by index from cookieStorage.\n *\n * @param {number} index The index of the cookie to retrieve.\n * @returns {string | null} The cookie value if found, or null if not found.\n */\nexport function getCookieByIndex(index: number): null | string {\n  try {\n    if (typeof document === \"undefined\") return null;\n\n    const cookies = document.cookie.split(\";\");\n    const cookie = cookies[index];\n\n    if (cookie) {\n      const [name] = cookie.split(\"=\");\n      if (name) return name.trim();\n    }\n  } catch (error) {\n    console.error(\"Error occurred while getting cookie by index:\", error);\n  }\n\n  return null;\n}\n","/**\n * Get the length of cookieStorage (the number of individual cookies).\n * @returns {number} The number of cookies in cookieStorage.\n */\nexport function getCookieStorageLength() {\n  try {\n    if (typeof document === \"undefined\") return 0;\n\n    const cookies = document.cookie.split(\";\");\n    return cookies.filter((cookie) => cookie.trim()).length;\n  } catch (error) {\n    console.error(\"Error occurred while getting cookieStorage length:\", error);\n  }\n\n  return 0;\n}\n","/**\n * Retrieves the value of a cookie by its name.\n *\n * @param {string} name The name of the cookie.\n * @returns {string | null} The value of the cookie, or null if the cookie is not found or if document is not defined.\n */\nexport function getCookieValue(name: string): null | string {\n  try {\n    if (typeof document === \"undefined\") return null;\n    const cookies = document.cookie.split(\";\");\n\n    for (let index = 0; index < cookies.length; index++) {\n      const cookieAtIndex = cookies.at(index);\n      if (!cookieAtIndex) continue;\n\n      const cookie = cookieAtIndex.trim();\n      if (cookie.startsWith(name + \"=\")) {\n        return cookie.substring(name.length + 1);\n      }\n    }\n  } catch (error) {\n    console.error(\"Error occurred while retrieving cookie:\", error);\n  }\n\n  return null;\n}\n","/**\n * Browser-compatible TypeScript implementation of HMAC-SHA256 cryptographic functions.\n * This implementation provides the same API as Node.js crypto module but works in browsers.\n */\n\nconst M = new Uint32Array(64);\nconst BLOCK_SIZE = 64;\nconst LITTLE_ENDIAN = (() => {\n  try {\n    return !!new Uint8Array(new Uint32Array([1]).buffer)[0];\n  } catch (e) {\n    return false;\n  }\n})();\n\nfunction convertEndian(word: number): number {\n  if (!LITTLE_ENDIAN) return word;\n  return (\n    (word >>> 24) |\n    ((word >>> 8) & 0xff00) |\n    ((word & 0xff00) << 8) |\n    (word << 24)\n  );\n}\n\nfunction getFractionalBits(n: number): number {\n  return ((n - (n | 0)) * 2 ** 32) | 0;\n}\n\nfunction rightRotate(word: number, bits: number): number {\n  return (word >>> bits) | (word << (32 - bits));\n}\n\nconst DEFAULT_STATE = (() => {\n  const state = new Uint32Array(8);\n  let n = 2,\n    nPrime = 0;\n  while (nPrime < 8) {\n    let isPrime = true;\n    for (let i = 2; i <= Math.sqrt(n); i++) {\n      if (n % i === 0) {\n        isPrime = false;\n        break;\n      }\n    }\n    if (isPrime) {\n      state[nPrime++] = getFractionalBits(Math.sqrt(n));\n    }\n    n++;\n  }\n  return state;\n})();\n\nconst ROUND_CONSTANTS = (() => {\n  const constants = [];\n  let n = 2,\n    nPrime = 0;\n  while (nPrime < 64) {\n    let isPrime = true;\n    for (let i = 2; i <= Math.sqrt(n); i++) {\n      if (n % i === 0) {\n        isPrime = false;\n        break;\n      }\n    }\n    if (isPrime) {\n      constants[nPrime++] = getFractionalBits(n ** (1 / 3));\n    }\n    n++;\n  }\n  return constants;\n})();\n\nclass Hmac {\n  private data: Uint8Array[] = [];\n  private key: Uint8Array;\n\n  constructor(key: string | Uint8Array) {\n    this.key = toUint8Array(key);\n    if (this.key.length > BLOCK_SIZE) this.key = SHA256.hash(this.key);\n    if (this.key.length < BLOCK_SIZE) {\n      const tmp = new Uint8Array(BLOCK_SIZE);\n      tmp.set(this.key);\n      this.key = tmp;\n    }\n  }\n\n  digest(encoding: \"base64\" | \"binary\" | \"hex\" = \"base64\"): string {\n    const msg = new Uint8Array(this.data.reduce((sum, a) => sum + a.length, 0));\n    let offset = 0;\n    for (const chunk of this.data)\n      msg.set(chunk, offset), (offset += chunk.length);\n\n    const oKeyPad = new Uint8Array(BLOCK_SIZE);\n    const iKeyPad = new Uint8Array(BLOCK_SIZE);\n    for (let i = 0; i < BLOCK_SIZE; i++) {\n      iKeyPad[i] = this.key[i] ^ 0x36;\n      oKeyPad[i] = this.key[i] ^ 0x5c;\n    }\n\n    const inner = SHA256.hash(concat(iKeyPad, msg));\n    const result = SHA256.hash(concat(oKeyPad, inner));\n\n    switch (encoding) {\n      case \"binary\":\n        return String.fromCharCode(...result);\n      case \"hex\":\n        return toHex(result);\n      default:\n        return toBase64(result);\n    }\n  }\n\n  update(data: string | Uint8Array): this {\n    this.data.push(toUint8Array(data));\n    return this;\n  }\n}\n\nexport class SHA256 {\n  public static hash(data: Uint8Array): Uint8Array {\n    const state = DEFAULT_STATE.slice();\n    const bitLength = data.length * 8;\n    const paddedLength = ((bitLength + 64 + 511) >> 9) << 9;\n\n    const buffer = new Uint8Array(paddedLength / 8);\n    buffer.set(data);\n    buffer[data.length] = 0x80;\n\n    const words = new Uint32Array(buffer.buffer);\n    words[words.length - 1] = convertEndian(bitLength);\n\n    for (let i = 0; i < words.length; i += 16) {\n      const w = M;\n      for (let t = 0; t < 64; t++) {\n        if (t < 16) w[t] = convertEndian(words[i + t]);\n        else {\n          const s0 =\n            rightRotate(w[t - 15], 7) ^\n            rightRotate(w[t - 15], 18) ^\n            (w[t - 15] >>> 3);\n          const s1 =\n            rightRotate(w[t - 2], 17) ^\n            rightRotate(w[t - 2], 19) ^\n            (w[t - 2] >>> 10);\n          w[t] = (w[t - 16] + s0 + w[t - 7] + s1) | 0;\n        }\n      }\n\n      let [a, b, c, d, e, f, g, h] = state;\n\n      for (let t = 0; t < 64; t++) {\n        const S1 = rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25);\n        const ch = (e & f) ^ (~e & g);\n        const temp1 = (h + S1 + ch + ROUND_CONSTANTS[t] + w[t]) | 0;\n        const S0 = rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22);\n        const maj = (a & b) ^ (a & c) ^ (b & c);\n        const temp2 = (S0 + maj) | 0;\n\n        [h, g, f, e, d, c, b, a] = [\n          g,\n          f,\n          e,\n          (d + temp1) | 0,\n          c,\n          b,\n          a,\n          (temp1 + temp2) | 0,\n        ];\n      }\n\n      for (let t = 0; t < 8; t++) {\n        state[t] = (state[t] + [a, b, c, d, e, f, g, h][t]) | 0;\n      }\n    }\n\n    return new Uint8Array(new Uint32Array(state.map(convertEndian)).buffer);\n  }\n}\n\nfunction concat(a: Uint8Array, b: Uint8Array): Uint8Array {\n  const res = new Uint8Array(a.length + b.length);\n  res.set(a);\n  res.set(b, a.length);\n  return res;\n}\n\nfunction toBase64(buf: Uint8Array): string {\n  return btoa(String.fromCharCode(...buf));\n}\n\nfunction toHex(buf: Uint8Array): string {\n  return Array.from(buf)\n    .map((b) => b.toString(16).padStart(2, \"0\"))\n    .join(\"\");\n}\n\nfunction toUint8Array(input: string | Uint8Array): Uint8Array {\n  return typeof input === \"string\" ? new TextEncoder().encode(input) : input;\n}\n\nexport const createHmac = (algorithm: \"sha256\", key: string | Uint8Array) => {\n  if (algorithm !== \"sha256\") throw new Error(\"Only 'sha256' is supported\");\n  return new Hmac(key);\n};\n","import { createHmac } from \"@/cookie-storage/helpers/create-hmac\";\n\n/**\n * Sign a cookie with a secret.\n *\n * @param cookie The cookie to sign.\n * @param secret The secret to sign the cookie with.\n *\n * @returns The signed cookie.\n */\nexport function signCookie(cookie: string, secret?: string): string {\n  if (!secret) return cookie;\n\n  try {\n    const signature = createHmac(\"sha256\", secret)\n      .update(cookie)\n      .digest(\"base64\")\n      .replace(/=+$/, \"\");\n\n    return [cookie, signature].join(\".\");\n  } catch (error) {\n    console.error(\"Error occurred while signing cookie:\", error);\n  }\n\n  return cookie;\n}\n","/**\n * Compare two strings in constant time to prevent timing attacks\n */\nexport function constantTimeCompare(a: string, b: string): boolean {\n  if (a.length !== b.length) return false;\n\n  let result = 0;\n  for (let index = 0; index < a.length; index++) {\n    result |= a.charCodeAt(index) ^ b.charCodeAt(index);\n  }\n\n  return result === 0;\n}\n","import { signCookie } from \"@/cookie-storage/functions/sign-cookie\";\nimport { constantTimeCompare } from \"@/cookie-storage/helpers/constant-time-compare\";\n\n/**\n * Unsign a signed cookie.\n *\n * @param signedCookie The signed cookie to unsign.\n * @param secret The secret to use for unsigning.\n *\n * @returns The unsigned cookie or null if the signed cookie is invalid.\n */\nexport function unsignCookie(\n  signedCookie: string,\n  secret: string\n): null | string {\n  try {\n    const demarcator = signedCookie.lastIndexOf(\".\");\n    if (demarcator === -1) return null;\n\n    const cookie = signedCookie.slice(0, demarcator);\n    const expectedSignature = signCookie(cookie, secret);\n\n    if (constantTimeCompare(expectedSignature, signedCookie)) {\n      return cookie;\n    }\n  } catch (error) {\n    console.error(\"Error occurred while unsigning cookie:\", error);\n  }\n\n  return null;\n}\n","import type { CookieStorage } from \"@/cookie-storage/types/cookie-storage\";\n\nimport { clearCookieStorage } from \"@/cookie-storage/functions/clear-cookie-storage\";\nimport { createCookieKey } from \"@/cookie-storage/functions/create-cookie-key\";\nimport { getCookieByIndex } from \"@/cookie-storage/functions/get-cookie-by-index\";\nimport { getCookieStorageLength } from \"@/cookie-storage/functions/get-cookie-storage-length\";\nimport { getCookieValue } from \"@/cookie-storage/functions/get-cookie-value\";\nimport { removeCookieValue } from \"@/cookie-storage/functions/remove-cookie-value\";\nimport { setCookieValue } from \"@/cookie-storage/functions/set-cookie-value\";\nimport { signCookie } from \"@/cookie-storage/functions/sign-cookie\";\nimport { unsignCookie } from \"@/cookie-storage/functions/unsign-cookie\";\n\n/**\n * An object representing a cookie storage with various methods to interact with cookies.\n */\nexport const cookieStorage = {\n  clear: clearCookieStorage,\n  createKey: createCookieKey,\n  getItem: getCookieValue,\n  key: getCookieByIndex,\n  get length() {\n    return getCookieStorageLength();\n  },\n  removeItem: removeCookieValue,\n  setItem: setCookieValue,\n  sign: signCookie,\n  unsign: unsignCookie,\n} as CookieStorage;\n","import type { Dictionary } from \"@/create-store/types/dictionary\";\n\n/**\n * Check if the value is a dictionary.\n *\n * @param value The value to check.\n *\n * @returns A boolean indicating whether the value is a dictionary.\n */\nexport function isDictionary(value: unknown): value is Dictionary {\n  return Object.prototype.toString.call(value) === \"[object Object]\";\n}\n","export function isPromise<State>(state: unknown): state is Promise<State> {\n  return state instanceof Promise;\n}\n","import type { DependencyList, Dispatch } from \"react\";\n\nimport type { CompositeStore } from \"@/create-store/types/composite-store\";\nimport type { Dictionary } from \"@/create-store/types/dictionary\";\nimport type { PartialStateManager } from \"@/create-store/types/partial-state-manager\";\nimport type { PartialStatePath } from \"@/create-store/types/partial-state-path\";\nimport type { Paths } from \"@/create-store/types/paths\";\nimport type { ResolvePath } from \"@/create-store/types/resolve-path\";\nimport type { Selector } from \"@/create-store/types/selector\";\nimport type { SetPartialStateAction } from \"@/create-store/types/set-partial-state-action\";\nimport type { StatePath } from \"@/create-store/types/state-path\";\nimport type { StoreValueResolver } from \"@/create-store/types/store-value-resolver\";\nimport type { Subscriber } from \"@/create-store/types/subscriber\";\n\nimport { useCallback, useSyncExternalStore } from \"react\";\n\nimport { isAccessor } from \"@/create-store/functions/assertions/is-accessor\";\nimport { isDictionary } from \"@/create-store/functions/assertions/is-dictionary\";\nimport { isFunction } from \"@/create-store/functions/assertions/is-function\";\nimport { isSetStateActionFunction } from \"@/create-store/functions/assertions/is-set-state-action-function\";\nimport { clone } from \"@/create-store/functions/helpers/clone\";\nimport { createPathComponents } from \"@/create-store/functions/helpers/create-path-components\";\nimport { createPaths } from \"@/create-store/functions/helpers/create-paths\";\nimport { replace } from \"@/create-store/functions/helpers/replace\";\nimport { splitPath } from \"@/create-store/functions/helpers/split-path\";\nimport { useSync } from \"@/create-store/functions/hooks/use-sync\";\nimport { resolvePath } from \"@/create-store/functions/utilities/resolve-path\";\nimport { resolveSelectorValue } from \"@/create-store/functions/utilities/resolve-selector-value\";\n\nexport function createCompositeStore<State extends Dictionary>(\n  initialState: State\n): CompositeStore<State> {\n  let state = initialState;\n\n  const cache = new WeakMap<any, CompositeStore<State>>();\n  const originalPaths = new Set<string>();\n\n  function trackOriginalPaths(\n    obj: any,\n    currentPath = \"\",\n    visited = new WeakSet()\n  ): void {\n    if (isDictionary(obj)) {\n      if (currentPath) {\n        originalPaths.add(currentPath);\n      }\n\n      for (const key in obj) {\n        const fullPath = currentPath ? `${currentPath}.${key}` : key;\n        originalPaths.add(fullPath);\n      }\n\n      if (visited.has(obj)) return;\n\n      visited.add(obj);\n      for (const key in obj) {\n        const fullPath = currentPath ? `${currentPath}.${key}` : key;\n        trackOriginalPaths(obj[key], fullPath, visited);\n      }\n    }\n  }\n\n  trackOriginalPaths(initialState);\n\n  const subscribers = new Map<\n    Paths<State>,\n    Set<(value: ResolvePath<State, Paths<State>>) => void>\n  >();\n\n  function getSubscribersByPath<Path extends Paths<State>>(\n    path: Path = \"\" as Path\n  ) {\n    if (!subscribers.has(path)) subscribers.set(path, new Set());\n    return subscribers.get(path)!;\n  }\n\n  function notifySubscribers(state: State, path?: Paths<State>) {\n    const resolvedValue = resolvePath(state, path);\n    const valuePaths = createPaths(resolvedValue);\n    const pathComponents = createPathComponents(path);\n    const paths = new Set([...pathComponents, ...valuePaths]);\n\n    subscribers.forEach((set, pathKey) => {\n      if (pathKey === \"\") {\n        set.forEach((subscriber) => {\n          subscriber(state as ResolvePath<State, Paths<State>>);\n        });\n      } else if (paths.has(pathKey)) {\n        const resolvedValue = resolvePath(state, pathKey);\n        set.forEach((subscriber) => subscriber(resolvedValue));\n      }\n    });\n  }\n\n  function setState<Path extends Paths<State>>(value: State, path?: Path) {\n    state = value;\n    notifySubscribers(value, path);\n  }\n\n  function setProperty<\n    Path extends Paths<State>,\n    Value extends ResolvePath<State, Path>,\n  >(value: Value, path: Path) {\n    const keys = splitPath(path);\n    const snapshot = clone(state);\n    const pivot = keys.pop()!;\n\n    let current: any = snapshot;\n    for (const key of keys) current = current[key];\n    current[pivot] = value;\n\n    setState(snapshot, path);\n  }\n\n  function get<\n    Path extends Paths<State>,\n    Value = StatePath<State, Path>,\n    Result = Value,\n  >(path?: Path, selector?: Selector<Value, Result>): Result {\n    const value = resolvePath(state, path);\n    return resolveSelectorValue(value, selector);\n  }\n\n  function set<\n    Path extends Paths<State>,\n    Value extends ResolvePath<State, Path>,\n  >(path: Path): Dispatch<SetPartialStateAction<Value>>;\n\n  function set<Path extends Paths<State> = never>(\n    path?: Path\n  ): Dispatch<SetPartialStateAction<State>>;\n\n  function set<Path extends Paths<State>>(path?: Path) {\n    if (!path) {\n      return (action: SetPartialStateAction<State>) => {\n        const next = isSetStateActionFunction<State>(action)\n          ? action(clone(state))\n          : action;\n        setState(replace(state, next));\n      };\n    }\n\n    return <Value extends ResolvePath<State, Path>>(\n      action: SetPartialStateAction<Value>\n    ) => {\n      const current = resolvePath(state, path);\n      const next = isSetStateActionFunction(action)\n        ? action(clone(current))\n        : action;\n      setProperty(replace(current, next), path);\n    };\n  }\n\n  function act<\n    Path extends Paths<State>,\n    Value extends ResolvePath<State, Path>,\n  >(subscriber: (value: Value) => void, path?: Path, immediate?: boolean) {\n    const subscribers = getSubscribersByPath(path);\n    const value = resolvePath(state, path);\n\n    subscribers.add(subscriber);\n    if (immediate) subscriber(value);\n\n    return () => {\n      subscribers.delete(subscriber);\n    };\n  }\n\n  function createSubscribe<Path extends Paths<State>>(path?: Path) {\n    return (callback: () => void) => act(callback, path);\n  }\n\n  function use<\n    Value extends StatePath<State, Path>,\n    Path extends Paths<State>,\n    Result = Value,\n  >(\n    path?: Path,\n    selector?: Selector<Value, Result>,\n    dependencies?: DependencyList\n  ): PartialStateManager<State, Result> {\n    const getSnapshot = useCallback(() => resolvePath(state, path), [path]);\n    const subscribe = useCallback(createSubscribe(path), [path]);\n    const setter = useCallback(set(path), [path]);\n\n    const value = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n    const resolvedValue = useSync(() => {\n      return resolveSelectorValue(value, selector);\n    }, [value, dependencies]);\n\n    return [resolvedValue, setter];\n  }\n\n  function joinPaths<Path extends Paths<State>>(\n    basePath?: Path,\n    property?: string\n  ): Path {\n    if (!basePath) return property as Path;\n    if (!property) return basePath;\n    return `${basePath}.${property}` as Path;\n  }\n\n  function resolveProperty<Path extends Paths<State>>(fullPath: Path) {\n    const value = resolvePath(state, fullPath);\n\n    if (isFunction(value)) return value;\n\n    if (isDictionary(value)) {\n      if (cache.has(value)) return cache.get(value);\n      return createProxy(fullPath);\n    }\n\n    return createProxy(fullPath);\n  }\n\n  function buildStore<Path extends Paths<State>>(chain?: Path) {\n    return {\n      $act(subscriber: Subscriber<State>, immediate = true) {\n        return act(subscriber, chain, immediate);\n      },\n      $get(selector?: Selector<StatePath<State, Path>>) {\n        return get(chain, selector);\n      },\n      $key(path: Path) {\n        const fullPath = joinPaths(chain, path);\n        return resolveProperty(fullPath) as StoreValueResolver<\n          ResolvePath<State, Path>\n        >;\n      },\n      $set(value: PartialStatePath<State, Path>) {\n        return set(chain)(value);\n      },\n      $use(\n        selector?: Selector<State, ResolvePath<State, Path>>,\n        dependencies?: DependencyList\n      ) {\n        return use(chain, selector, dependencies);\n      },\n    };\n  }\n\n  function createProxy<Path extends Paths<State>>(path?: Path) {\n    const value = resolvePath(state, path);\n\n    if (isDictionary(value) && cache.has(value)) {\n      return cache.get(value)!;\n    }\n\n    const node = buildStore(path) as CompositeStore<State>;\n\n    const proxy = new Proxy(node, {\n      defineProperty() {\n        return true;\n      },\n\n      deleteProperty() {\n        return true;\n      },\n\n      get(target, prop) {\n        if (typeof prop === \"string\") {\n          if (isAccessor(target, prop)) {\n            return target[prop];\n          }\n\n          const fullPath = joinPaths(path, prop);\n          const pathExistedInOriginal = originalPaths.has(fullPath);\n\n          if (pathExistedInOriginal) {\n            return resolveProperty(fullPath);\n          }\n        }\n        return target[prop];\n      },\n\n      getOwnPropertyDescriptor(target, prop) {\n        if (typeof prop === \"string\") {\n          if (isAccessor(target, prop)) {\n            return {\n              configurable: true,\n              enumerable: false,\n              value: target[prop],\n              writable: false,\n            };\n          }\n\n          const fullPath = joinPaths(path, prop);\n          const pathExistedInOriginal = originalPaths.has(fullPath);\n\n          if (pathExistedInOriginal) {\n            return {\n              configurable: true,\n              enumerable: true,\n              get: () => resolveProperty(fullPath),\n              set: () => true,\n            };\n          }\n        }\n        return undefined;\n      },\n\n      has(target, prop) {\n        if (typeof prop === \"string\") {\n          if (isAccessor(target, prop)) return true;\n\n          const fullPath = joinPaths(path, prop);\n          return originalPaths.has(fullPath);\n        }\n        return false;\n      },\n\n      ownKeys() {\n        const value = resolvePath(state, path);\n        return isDictionary(value) ? Reflect.ownKeys(value) : [];\n      },\n\n      set() {\n        return true;\n      },\n    });\n\n    if (isDictionary(value)) {\n      cache.set(value, proxy);\n    }\n\n    return proxy;\n  }\n\n  return createProxy();\n}\n","type Accessor = \"$act\" | \"$get\" | \"$set\" | \"$use\";\n\nexport function isAccessor<Target extends Record<string, any>>(\n  target: Target,\n  prop: string | symbol\n): prop is Accessor {\n  if (typeof prop === \"string\") {\n    return prop.startsWith(\"$\") && prop in target;\n  }\n\n  return false;\n}\n","import type { Initializer } from \"@/create-store/types/initializer\";\n\nexport function isFunction<State>(value: unknown): value is Initializer<State> {\n  return typeof value === \"function\";\n}\n","/**\n * Type guard to check if a value is a SetStateAction function.\n *\n * @template Value The type of the state.\n * @param {unknown} value The value to be checked.\n * @returns {boolean} `true` if the value is a SetStateAction function, otherwise `false`.\n */\nexport function isSetStateActionFunction<Value>(\n  value: unknown\n): value is (prev: Value) => Value {\n  return typeof value === \"function\";\n}\n","export type CloneFunction = <Value = any>(\n  value: Value,\n  visited?: WeakMap<object, any>\n) => Value;\nexport type CloneHandler<Value = any, Result = Value> = (\n  value: Value,\n  visited: WeakMap<object, any>,\n  clone: CloneFunction\n) => Result;\nexport type CloneRegistryModifier = (registry: CloneRegistry) => void;\nexport type CloneValidator = (value: any) => boolean;\nexport type Constructor<T = any> = new (...args: any[]) => T;\n\n/**\n * Clone handler registry\n *\n * @description\n * Manages clone handlers mapped to constructors. Enables registration and lookup of handlers for specific types,\n * allowing the clone function to deeply copy objects while maintaining their structure and properties.\n */\nexport class CloneRegistry {\n  private handlers: WeakMap<any, CloneHandler> = new WeakMap();\n  private validators: WeakMap<any, CloneValidator> = new WeakMap();\n\n  /**\n   * Get a clone handler for a specific value\n   *\n   * @description\n   * This method retrieves the appropriate clone handler for the given value based on its constructor.\n   * If no handler is found, it returns null. If no validator is found, it returns true.\n   *\n   * @param value The value for which to get the handler\n   * @returns The clone handler for the value or null if not found\n   */\n  getHandler(value: any): [CloneHandler | null, CloneValidator] {\n    const constructor = getConstructor(value);\n\n    return [\n      this.handlers.get(constructor) ?? null,\n      this.validators.get(constructor) ?? (() => true),\n    ];\n  }\n\n  /**\n   * Check if a constructor is registered\n   *\n   * @description\n   * This method checks if a handler is registered for the given constructor.\n   * It returns true if a handler exists, false otherwise.\n   *\n   * @param constructor The constructor to check for a registered handler\n   * @returns True if a handler is registered, false otherwise\n   */\n  hasHandler(constructor: any): boolean {\n    return this.handlers.has(constructor);\n  }\n\n  /**\n   * Register a handler for a specific constructor\n   *\n   * @description\n   * This method registers a clone handler and a validator function for the specified constructor.\n   * It allows the clone function to use the handler when cloning instances of that constructor.\n   * The validator is used to check if a value is of the expected type before cloning.\n   *\n   * @param constructor The constructor for which to register the handler\n   * @param handler The clone handler to register\n   * @param validator The validator function to register\n   *\n   * @returns The CloneRegistry instance for method chaining\n   */\n  setHandler<T>(\n    constructor: Constructor<T> | Function,\n    handler: CloneHandler<T>,\n    validator?: CloneValidator\n  ) {\n    this.handlers.set(constructor, handler);\n\n    if (validator) {\n      this.validators.set(constructor, validator);\n    }\n\n    return this;\n  }\n}\n\n/**\n * Pre-built validators for common types\n *\n * @description\n * This object contains methods that validate if a value is of a specific type.\n * These validators are used by the clone function to ensure that values are of the expected type before cloning.\n */\nexport const Validators = {\n  /**\n   * Validates if the result is an array\n   *\n   * @param result The value to validate\n   * @returns True if the value is an array, false otherwise\n   */\n  Array: (result: any): result is any[] => {\n    return Array.isArray(result);\n  },\n\n  /**\n   * Validates if the result is an ArrayBuffer\n   *\n   * @param result The value to validate\n   * @returns True if the value is an ArrayBuffer, false otherwise\n   */\n  AsyncFunction: (result: any): result is Function => {\n    return (\n      typeof result === \"function\" &&\n      result.constructor.name === \"AsyncFunction\"\n    );\n  },\n\n  /**\n   * Validates if the result is an AsyncGeneratorFunction\n   *\n   * @param result The value to validate\n   * @returns True if the value is an AsyncGeneratorFunction, false otherwise\n   */\n  AsyncGeneratorFunction: (result: any): result is Function => {\n    return (\n      typeof result === \"function\" &&\n      result.constructor.name === \"AsyncGeneratorFunction\"\n    );\n  },\n\n  /**\n   * Validates if the result is a Date object\n   *\n   * @param result The value to validate\n   * @returns True if the value is a Date object, false otherwise\n   */\n  Date: (result: any): result is Date => {\n    return result instanceof Date && !isNaN(result.getTime());\n  },\n\n  /**\n   * Validates if the result is a Function\n   *\n   * @param result The value to validate\n   * @returns True if the value is a Function, false otherwise\n   */\n  Function: (result: any): result is Function => {\n    return typeof result === \"function\";\n  },\n\n  /**\n   * Validates if the result is a GeneratorFunction\n   *\n   * @param result The value to validate\n   * @returns True if the value is a GeneratorFunction, false otherwise\n   */\n  GeneratorFunction: (result: any): result is Function => {\n    return (\n      typeof result === \"function\" &&\n      result.constructor.name === \"GeneratorFunction\"\n    );\n  },\n\n  /**\n   * Validates if the result is an object\n   *\n   * @param result The value to validate\n   * @returns True if the value is an object, false otherwise\n   */\n  Object: (result: any): result is object => {\n    return result !== null && typeof result === \"object\";\n  },\n};\n\n/**\n * Pre-built handlers for common types\n *\n * @description\n * This object contains methods that handle cloning for various types.\n * Each method takes a value, a WeakMap to track visited objects, and the clone function\n * itself to handle circular references. These handlers are used by the clone function\n * to create deep copies of complex objects while preserving their structure and properties.\n */\nexport const Handlers = {\n  /**\n   * Clones an array by iterating over its items and cloning each one.\n   * It uses a WeakMap to track visited objects to handle circular references.\n   *\n   * @param value The array to clone\n   * @param visited A WeakMap to track visited objects\n   * @param clone The clone function to handle cloning of values\n   * @returns A new array containing cloned items\n   */\n  Array: <T>(\n    value: T[],\n    visited: WeakMap<object, any>,\n    clone: CloneFunction\n  ): T[] => {\n    const length = value.length;\n    const result = new Array(length);\n    visited.set(value, result);\n\n    for (let key = 0; key < length; key++) {\n      if (key in value) {\n        result[key] = clone(value[key], visited);\n      }\n    }\n\n    return result;\n  },\n\n  /**\n   * Clones an ArrayBuffer by creating a new instance with the same byte data.\n   *\n   * @param value The ArrayBuffer to clone\n   * @returns A new ArrayBuffer with the same data\n   */\n  ArrayBuffer: (value: ArrayBuffer) => value.slice(),\n\n  /**\n   * Clones an async function by creating a new instance that behaves like a constructor.\n   * It copies properties from the original function to the new instance.\n   *\n   * @param value The async function to clone\n   * @param visited A WeakMap to track visited objects\n   * @param clone The clone function to handle cloning of values\n   * @returns A new async function that behaves like a constructor\n   */\n  AsyncFunction: (value: Function) => createAsyncInstance(value as any),\n\n  /**\n   * Clones an async generator function by creating a new instance that behaves like an async generator.\n   * It copies properties from the original function to the new instance.\n   *\n   * @param value The async generator function to clone\n   * @param visited A WeakMap to track visited objects\n   * @param clone The clone function to handle cloning of values\n   * @returns A new async generator function that behaves like a constructor\n   */\n  AsyncGeneratorFunction: (value: Function) => {\n    const result = createAsyncGeneratorInstance(\n      value as AsyncGeneratorFunction\n    );\n    return result;\n  },\n\n  Blob: (value: Blob) => new Blob([value], { type: value.type }),\n\n  /**\n   * Clones a DataView by creating a new instance with the same buffer, byteOffset, and byteLength.\n   *\n   * @param value The DataView to clone\n   * @returns A new DataView with the same data\n   */\n  DataView: (value: DataView) => {\n    return new DataView(\n      value.buffer.slice(),\n      value.byteOffset,\n      value.byteLength\n    );\n  },\n\n  /**\n   * Clones a Date by creating a new instance with the same time value.\n   *\n   * @param value The Date to clone\n   * @returns A new Date with the same time value\n   */\n  Date: (value: Date) => new Date(value.getTime()),\n\n  /**\n   * Clones an Error by creating a new instance with the same message and name.\n   * It also copies properties from the original error to the new instance.\n   *\n   * @param value The Error to clone\n   * @param visited A WeakMap to track visited objects\n   * @param clone The clone function to handle cloning of values\n   * @returns A new Error with the same message and properties\n   */\n  Error: (value: Error) => {\n    const Constructor = value.constructor as ErrorConstructor;\n    const result = new Constructor(value.message);\n    result.name = value.name;\n\n    if (value.stack) result.stack = value.stack;\n    return result;\n  },\n\n  /**\n   * Clones a File by creating a new instance with the same name, lastModified, and type.\n   *\n   * @param value The File to clone\n   * @returns A new File with the same properties\n   */\n  File: (value: File) => {\n    const result = new File([value], value.name, {\n      lastModified: value.lastModified,\n      type: value.type,\n    });\n    return result;\n  },\n\n  /**\n   * Clones a FormData by creating a new instance and appending all key-value pairs.\n   *\n   * @param value The FormData to clone\n   * @returns A new FormData with the same key-value pairs\n   */\n  FormData: (value: FormData) => {\n    const result = new FormData();\n\n    value.forEach((item, key) => {\n      result.append(key, item);\n    });\n\n    return result;\n  },\n\n  /**\n   * Clones a function by creating a new instance that behaves like a constructor.\n   * It copies properties from the original function to the new instance.\n   *\n   * @param value The function to clone\n   * @param visited A WeakMap to track visited objects\n   * @param clone The clone function to handle cloning of values\n   * @returns A new function that behaves like a constructor\n   */\n  Function: (value: Function) => createInstance(value),\n\n  /**\n   * Clones a generator function by creating a new instance that behaves like a generator.\n   * It copies properties from the original function to the new instance.\n   *\n   * @param value The generator function to clone\n   * @param visited A WeakMap to track visited objects\n   * @param clone The clone function to handle cloning of values\n   * @returns A new generator function that behaves like a constructor\n   */\n  GeneratorFunction: (value: Function) => {\n    return createGeneratorInstance(value as GeneratorFunction);\n  },\n\n  /**\n   * Identity handler that returns the value as is.\n   * Used for types that do not require deep cloning, such as WeakMap, WeakSet, and WeakRef.\n   *\n   * @param value The value to return\n   * @returns The same value\n   */\n  Identity: <T>(value: T) => value,\n\n  /**\n   * Clones a Map by iterating over its items and cloning each key-value pair.\n   * It uses a WeakMap to track visited objects to handle circular references.\n   *\n   * @param value The Map to clone\n   * @param visited A WeakMap to track visited objects\n   * @param clone The clone function to handle cloning of values\n   * @returns A new Map containing cloned items\n   */\n  Map: <K, V>(\n    value: Map<K, V>,\n    visited: WeakMap<object, any>,\n    clone: CloneFunction\n  ): Map<K, V> => {\n    const result = new Map<K, V>();\n    visited.set(value, result);\n\n    value.forEach((item, key) => {\n      result.set(clone(key, visited), clone(item, visited));\n    });\n\n    return result;\n  },\n\n  /**\n   * Clones an object by creating a new instance and copying properties from the original object.\n   * It uses a WeakMap to track visited objects to handle circular references.\n   *\n   * @param value The object to clone\n   * @param visited A WeakMap to track visited objects\n   * @param clone The clone function to handle cloning of values\n   * @returns A new object with the same properties\n   */\n  Object: (value: any) => Object.create(Object.getPrototypeOf(value)),\n\n  /**\n   * Clones a Promise by creating a new Promise that resolves with the cloned value.\n   * It uses a WeakMap to track visited objects to handle circular references.\n   *\n   * @param value The Promise to clone\n   * @param visited A WeakMap to track visited objects\n   * @param clone The clone function to handle cloning of values\n   * @returns A new Promise that resolves with the cloned value\n   */\n  Promise: (\n    value: Promise<any>,\n    visited: WeakMap<object, any>,\n    clone: CloneFunction\n  ): Promise<any> => {\n    const result = new Promise((resolve, reject) => {\n      value.then(\n        (resolved) => resolve(clone(resolved, visited)),\n        (error) => reject(clone(error, visited))\n      );\n    });\n\n    return result;\n  },\n\n  /**\n   * Clones a RegExp by creating a new instance with the same source and flags.\n   *\n   * @param value The RegExp to clone\n   * @returns A new RegExp with the same source and flags\n   */\n  RegExp: (value: RegExp) => new RegExp(value.source, value.flags),\n\n  /**\n   * Clones a Set by iterating over its items and cloning each one.\n   * It uses a WeakMap to track visited objects to handle circular references.\n   *\n   * @param value The Set to clone\n   * @param visited A WeakMap to track visited objects\n   * @param clone The clone function to handle cloning of values\n   * @returns A new Set containing cloned items\n   */\n  Set: <T>(\n    value: Set<T>,\n    visited: WeakMap<object, any>,\n    clone: CloneFunction\n  ): Set<T> => {\n    const result = new Set<T>();\n    visited.set(value, result);\n\n    value.forEach((item) => {\n      result.add(clone(item, visited));\n    });\n\n    return result;\n  },\n\n  /**\n   * Clones a TypedArray by creating a new instance with the same buffer, byteOffset, and length.\n   *\n   * @param value The TypedArray to clone\n   * @returns A new TypedArray with the same data\n   */\n  TypedArray: (value: any) => {\n    return new value.constructor(\n      value.buffer.slice(),\n      value.byteOffset,\n      value.length\n    );\n  },\n\n  /**\n   * Clones a URL by creating a new instance with the same href.\n   *\n   * @param value The URL to clone\n   * @returns A new URL with the same href\n   */\n  URL: (value: URL) => new URL(value.href),\n\n  /**\n   * Clones a URLSearchParams by creating a new instance with the same query parameters.\n   *\n   * @param value The URLSearchParams to clone\n   * @returns A new URLSearchParams with the same query parameters\n   */\n  URLSearchParams: (value: URLSearchParams) => new URLSearchParams(value),\n};\n\n/**\n * Creates a new clone function with a customizable registry\n *\n * @description\n * This function creates a new clone function that uses the provided registry modifier\n * to customize the default registry. It handles circular references using a WeakMap\n * and applies the appropriate clone handler based on the value's constructor.\n * If no handler is found, it falls back to the generic object handler.\n *\n * @param registryModifier Optional function to modify the default registry\n * @returns A clone function that can be used to deep clone objects\n *\n * @example\n *\n * ```ts\n * import { createCloneFunction } from '@ibnlanre/clone';\n *\n * // Custom registry modifier to add a new handler\n * const customRegistryModifier: CloneRegistryHandler = (registry) => {\n *   registry.setHandler(MyCustomType, (value, visited, clone) => {\n *     // Custom cloning logic for MyCustomType\n *     const result = new MyCustomType(value.prop);\n *     visited.set(value, result);\n *     return result;\n *   });\n * };\n *\n * // Create a clone function with the custom registry\n * const clone = createCloneFunction(customRegistryModifier);\n * ```\n */\nexport function createCloneFunction(\n  registryModifier?: CloneRegistryModifier\n): CloneFunction {\n  const registry = new CloneRegistry();\n\n  if (registryModifier) registryModifier(registry);\n  else createDefaultRegistry(registry);\n\n  const clone: CloneFunction = <T>(\n    value: T,\n    visited?: WeakMap<object, any>\n  ): T => {\n    if (isPrimitive(value)) return value;\n\n    if (!visited) visited = new WeakMap();\n\n    if (visited.has(value as object)) {\n      return visited.get(value as object);\n    }\n\n    const [handler, validator] = registry.getHandler(value);\n\n    if (handler) {\n      const result = handler(value, visited, clone);\n      copyProperties(result, value, visited, clone);\n\n      if (validator(result)) return result;\n    }\n\n    return value;\n  };\n\n  return clone;\n}\n\n/**\n * Create a new async generator instance that behaves like an async generator function\n *\n * @description\n * This function creates a new async generator instance that can be used as an async generator function.\n * The original function is called directly to preserve its lexical scope and closure variables.\n * The function maintains proper constructor behavior while ensuring all closure variables\n * captured in the original function remain accessible.\n *\n * @param value The async generator function to create an instance of\n * @returns A new async generator function that behaves like a constructor with preserved closures\n */\nfunction createAsyncGeneratorInstance<T extends AsyncGeneratorFunction>(\n  value: T\n) {\n  const result = async function* (this: any, ...args: any[]) {\n    if (new.target) {\n      const instance = Object.create(result.prototype);\n\n      // Call the original function directly to preserve its closure\n      const generator = value.apply(instance, args);\n\n      if (generator && typeof generator.next === \"function\") {\n        yield* generator;\n      } else {\n        return isNonObject(generator) ? instance : generator;\n      }\n    } else {\n      // Call the original function directly to preserve its closure\n      yield* value.apply(this, args);\n    }\n  };\n\n  return result;\n}\n\n/**\n * Create a new async instance of a function with the same prototype\n *\n * @description\n * This function creates a new async instance of a function that behaves like a constructor.\n * The original function is called directly to preserve its lexical scope and closure variables.\n * The function maintains proper constructor behavior while ensuring all closure variables\n * captured in the original function remain accessible.\n *\n * @param value The async function to create an instance of\n * @returns A new async function that behaves like a constructor with preserved closures\n */\nfunction createAsyncInstance<T extends (...args: any[]) => Promise<any>>(\n  value: T\n) {\n  const result = async function (this: any, ...args: any[]) {\n    if (new.target) {\n      const instance = Object.create(result.prototype);\n\n      // Call the original function directly to preserve its closure\n      const method = await value.apply(instance, args);\n\n      return isNonObject(method) ? instance : method;\n    }\n    // Call the original function directly to preserve its closure\n    return await value.apply(this, args);\n  };\n\n  return result;\n}\n\n/**\n * Create a default registry with common handlers\n *\n * @description\n * This function creates a new clone registry and registers handlers for common types\n * such as Date, RegExp, Array, Map, Set, and others. It also registers function constructors\n * and typed array constructors to handle cloning of these types.\n *\n * @returns A new CloneRegistry instance with default handlers registered\n */\nfunction createDefaultRegistry(registry: CloneRegistry) {\n  registry\n    .setHandler(Date, Handlers.Date, Validators.Date)\n    .setHandler(RegExp, Handlers.RegExp)\n    .setHandler(Array, Handlers.Array, Validators.Array)\n    .setHandler(Map, Handlers.Map)\n    .setHandler(Set, Handlers.Set)\n    .setHandler(ArrayBuffer, Handlers.ArrayBuffer)\n    .setHandler(DataView, Handlers.DataView)\n    .setHandler(Error, Handlers.Error)\n    .setHandler(URL, Handlers.URL)\n    .setHandler(URLSearchParams, Handlers.URLSearchParams)\n    .setHandler(FormData, Handlers.FormData)\n    .setHandler(Blob, Handlers.Blob)\n    .setHandler(File, Handlers.File)\n    .setHandler(Object, Handlers.Object)\n    .setHandler(Proxy, Handlers.Identity);\n\n  registerFunctionConstructors(registry);\n  registerTypedArrayConstructors(registry);\n  registerWeakCollections(registry);\n\n  return registry;\n}\n\n/**\n * Create a new generator instance that behaves like a generator function\n *\n * @description\n * This function creates a new generator instance that can be used as a generator function.\n * The original function is called directly to preserve its lexical scope and closure variables.\n * The function maintains proper constructor behavior while ensuring all closure variables\n * captured in the original function remain accessible.\n *\n * @param value The generator function to create an instance of\n * @returns A new generator function that behaves like a constructor with preserved closures\n */\nfunction createGeneratorInstance<T extends GeneratorFunction>(value: T) {\n  const result = function* (this: any, ...args: any[]) {\n    if (new.target) {\n      const instance = Object.create(result.prototype);\n\n      // Call the original function directly to preserve its closure\n      const generator = value.apply(instance, args);\n\n      if (generator && typeof generator.next === \"function\") {\n        yield* generator;\n      } else {\n        return isNonObject(generator) ? instance : generator;\n      }\n    } else {\n      // Call the original function directly to preserve its closure\n      yield* value.apply(this, args);\n    }\n  };\n\n  return result;\n}\n\n/**\n * Create a new instance of a function with the same prototype\n *\n * @description\n * This function creates a new instance of a function that behaves like a constructor.\n * The original function is called directly to preserve its lexical scope and closure variables.\n * The function maintains proper constructor behavior while ensuring all closure variables\n * captured in the original function remain accessible.\n *\n * @param value The function to create an instance of\n * @returns A new function that behaves like a constructor with preserved closures\n */\nfunction createInstance<T extends Function>(value: T) {\n  const result = function (this: any, ...args: any[]) {\n    if (new.target) {\n      const instance = Object.create(result.prototype);\n\n      // Call the original function directly to preserve its closure\n      const method = value.apply(instance, args);\n\n      return isNonObject(method) ? instance : method;\n    }\n\n    // Call the original function directly to preserve its closure\n    return value.apply(this, args);\n  };\n\n  return result;\n}\n\n/**\n * Get the constructor of a value\n *\n * @description\n * This function retrieves the constructor of the provided value.\n * It uses `Object.getPrototypeOf` to get the prototype and then accesses the `constructor` property.\n *\n * @param value The value for which to get the constructor\n * @returns The constructor function of the value\n */\nfunction getConstructor<T>(value: T): Function {\n  return Object.getPrototypeOf(value).constructor;\n}\n\n/**\n * Check if a type is not an object or function\n *\n * @description\n * This function checks if the provided type is neither an object nor a function.\n * It returns true for primitive types (null, undefined, string, number, boolean, symbol, bigint)\n * and false for objects and functions.\n *\n * @param type The type to check\n * @returns True if the type is not an object or function, false otherwise\n */\nfunction isNonObject<T>(type: T) {\n  return type !== \"object\" && type !== \"function\";\n}\n\n/**\n * Check if a value is a primitive type\n *\n * @description\n * This function checks if the provided value is a primitive type (null, undefined, string, number, boolean, symbol, or bigint).\n * It returns true for these types and false for objects and functions.\n *\n * @param value The value to check\n * @returns True if the value is a primitive type, false otherwise\n */\nfunction isPrimitive<T>(value: T) {\n  if (value === null || value === undefined) return true;\n  return isNonObject(typeof value);\n}\n\n/**\n * Check if a property descriptor indicates a property accessor\n *\n * @description\n * This function checks if the provided property descriptor indicates that the property is an accessor (getter/setter)\n * or has specific characteristics that make it non-enumerable, non-configurable, or non-writable.\n *\n * @param descriptor The property descriptor to check\n * @param key The property key being checked\n *\n * @returns True if the descriptor indicates a property accessor, false otherwise\n */\nfunction isPropertyAccessor(descriptor: PropertyDescriptor) {\n  return (\n    descriptor.get ||\n    descriptor.set ||\n    !descriptor.enumerable ||\n    !descriptor.configurable ||\n    !descriptor.writable\n  );\n}\n\n/**\n * Get all function constructor types\n *\n * @description\n * This function dynamically retrieves constructors for different function types\n * including AsyncFunction, GeneratorFunction, and AsyncGeneratorFunction.\n * These constructors are not globally available, so we get them from instances.\n *\n * @returns Array of function constructors\n */\nfunction registerFunctionConstructors(registry: CloneRegistry) {\n  const asyncGeneratorFunction = async function* () {};\n  const AsyncGeneratorFunction = getConstructor(asyncGeneratorFunction);\n\n  registry.setHandler(\n    AsyncGeneratorFunction,\n    Handlers.AsyncGeneratorFunction,\n    Validators.AsyncGeneratorFunction\n  );\n\n  const generatorFunction = function* () {};\n  const GeneratorFunction = getConstructor(generatorFunction);\n\n  registry.setHandler(\n    GeneratorFunction,\n    Handlers.GeneratorFunction,\n    Validators.GeneratorFunction\n  );\n\n  const asyncFunction = async function () {};\n  const AsyncFunction = getConstructor(asyncFunction);\n\n  registry.setHandler(\n    AsyncFunction,\n    Handlers.AsyncFunction,\n    Validators.AsyncFunction\n  );\n\n  registry.setHandler(Promise, Handlers.Promise);\n  registry.setHandler(Function, Handlers.Function, Validators.Function);\n}\n\n/**\n * Register handlers for typed array constructors\n *\n * @description\n * This function registers handlers for all typed array constructors in the clone registry.\n * It uses the TypedArray handler to handle cloning of typed arrays.\n *\n * @param registry The clone registry to register the handlers in\n */\nfunction registerTypedArrayConstructors(registry: CloneRegistry) {\n  const typedArrays = [\n    Int8Array,\n    Uint8Array,\n    Uint8ClampedArray,\n    Int16Array,\n    Uint16Array,\n    Int32Array,\n    Uint32Array,\n    Float32Array,\n    Float64Array,\n    BigInt64Array,\n    BigUint64Array,\n  ];\n\n  typedArrays.forEach((Constructor) => {\n    registry.setHandler(Constructor, Handlers.TypedArray);\n  });\n}\n\n/**\n * Register handlers for weak collections\n *\n * @description\n * This function registers handlers for WeakMap, WeakSet, and WeakRef in the clone registry.\n * These handlers use the Identity handler since weak collections do not need deep cloning.\n *\n * @param registry The clone registry to register the handlers in\n */\nfunction registerWeakCollections(registry: CloneRegistry) {\n  const weakCollections: Constructor[] = [WeakMap, WeakSet, WeakRef];\n\n  weakCollections.forEach((Constructor) => {\n    registry.setHandler(Constructor, Handlers.Identity);\n  });\n}\n\n/**\n * Creates a deep clone of a value using the default registry.\n *\n * @param value The value to clone.\n * @param visited A WeakMap to track visited objects to prevent circular references.\n *\n * @returns The cloned value.\n */\nconst clone = createCloneFunction();\nexport default clone;\n\n/**\n * Copy properties from one object to another\n *\n * @description\n * This function copies properties from the source object to the target object.\n * It handles both regular properties and symbols, and uses the provided clone function\n * to handle circular references.\n *\n * @param result The target object where properties will be copied\n * @param value The source object from which properties will be copied\n * @param visited A WeakMap to track visited objects for circular references\n * @param clone The clone function to handle cloning of values\n *\n * @returns The target object with copied properties\n */\nexport function copyProperties(\n  result: any,\n  value: any,\n  visited: WeakMap<object, any>,\n  clone: CloneFunction\n) {\n  visited.set(value, result);\n\n  if (!Object.isExtensible(result)) return result;\n\n  const properties = Object.getOwnPropertyNames(value);\n  if (properties.length) {\n    for (let index = 0; index < properties.length; index++) {\n      const key = properties[index];\n\n      if (typeof value === \"function\") {\n        if (\n          key === \"constructor\" ||\n          key === \"name\" ||\n          key === \"length\" ||\n          key === \"arguments\" ||\n          key === \"caller\" ||\n          key === \"callee\"\n        ) {\n          continue;\n        }\n      }\n\n      if (key === \"prototype\" || key === \"__proto__\") {\n        Object.assign(result[key], value[key]);\n        continue;\n      }\n\n      const descriptor = Object.getOwnPropertyDescriptor(value, key);\n\n      if (descriptor) {\n        if (isPropertyAccessor(descriptor)) {\n          Object.defineProperty(result, key, descriptor);\n        } else {\n          result[key] = clone(value[key], visited);\n        }\n      }\n    }\n  }\n\n  const symbols = Object.getOwnPropertySymbols(value);\n  if (symbols.length) {\n    for (let index = 0; index < symbols.length; index++) {\n      const key = symbols[index];\n\n      if (\n        key === Symbol.iterator ||\n        key === Symbol.toStringTag ||\n        key === Symbol.species ||\n        key === Symbol.unscopables ||\n        key === Symbol.asyncIterator ||\n        key === Symbol.match ||\n        key === Symbol.replace ||\n        key === Symbol.search ||\n        key === Symbol.split ||\n        key === Symbol.hasInstance ||\n        key === Symbol.isConcatSpreadable ||\n        key === Symbol.toPrimitive ||\n        key === Symbol.matchAll ||\n        key === Symbol.metadata ||\n        key === Symbol.dispose ||\n        key === Symbol.asyncDispose\n      ) {\n        continue;\n      }\n\n      const descriptor = Object.getOwnPropertyDescriptor(value, key);\n\n      if (descriptor) {\n        if (isPropertyAccessor(descriptor)) {\n          Object.defineProperty(result, key, descriptor);\n        } else {\n          result[key] = clone(descriptor.value, visited);\n        }\n      }\n    }\n  }\n\n  return result;\n}\n","import { createCloneFunction, Handlers } from \"@ibnlanre/clone\";\n\n/**\n * Safely clones a value while preserving functions by reference.\n * This is the preferred clone function to use in store implementations.\n *\n * @param value The value to clone\n * @returns A cloned value with functions preserved by reference\n */\nexport const clone = createCloneFunction((registry) => {\n  registry\n    .setHandler(Object, Handlers.Object)\n    .setHandler(Array, Handlers.Array);\n});\n","import type { Components } from \"@/create-store/types/components\";\n\n/**\n * Creates an array of path components from a given path string.\n *\n * @description\n * This function takes a path string and splits it into components based on the dot notation.\n * It generates an array of components where each component represents a segment of the path.\n *\n * @param path The path string to split into components.\n * @returns An array of path components.\n */\nexport function createPathComponents<Path extends string>(\n  path?: Path\n): Components<Path> {\n  if (!path) return [] as unknown as Components<Path>;\n\n  const segments = path.split(\".\");\n  const result = new Array(segments.length);\n  let current = segments[0];\n  result[0] = current;\n\n  for (let index = 1; index < segments.length; index++) {\n    current += \".\" + segments[index];\n    result[index] = current;\n  }\n\n  return result as Components<Path>;\n}\n","import type { Dictionary } from \"@/create-store/types/dictionary\";\n\nimport { isDictionary } from \"@/create-store/functions/assertions/is-dictionary\";\n\n/**\n * Creates an array of paths from a given store object.\n *\n * @description\n * This function recursively traverses the store object and generates a list of paths\n *\n * @param store The store object to create paths from.\n * @param prefix An array of strings representing the current path prefix.\n * @param visited A WeakSet to track visited objects and prevent cyclic references.\n *\n * @returns An array of strings representing the paths in the store object.\n */\nexport function createPaths<Store extends Dictionary>(\n  store: Store,\n  prefix: string[] = [],\n  visited = new WeakSet()\n): string[] {\n  if (!isDictionary(store)) return [];\n\n  const paths: string[] = [];\n\n  for (const key in store) {\n    const value = store[key];\n    const path = [...prefix, key].join(\".\");\n\n    paths.push(path);\n\n    if (isDictionary(value)) {\n      if (visited.has(value)) continue;\n      visited.add(value);\n      paths.push(...createPaths(value, [...prefix, key], visited));\n    }\n  }\n\n  return paths;\n}\n","import type { Primitives } from \"@/create-store/types/primitives\";\n\n/**\n * Checks if a value is a primitive type.\n * Primitives include: null, undefined, boolean, number, string, symbol, and bigint.\n *\n * @param value The value to check\n * @returns True if the value is a primitive type, false otherwise\n */\nexport function isPrimitive(value: unknown): value is Primitives {\n  if (value === null || value === undefined) return true;\n  return typeof value !== \"object\" && typeof value !== \"function\";\n}\n","import type { DeepPartial } from \"@/create-store/types/deep-partial\";\nimport type { Dictionary } from \"@/create-store/types/dictionary\";\n\nimport { isPrimitive } from \"@/create-store/functions/assertions/is-primitive\";\n\nexport function isDictionarySlice<Target extends Dictionary>(\n  target: Target,\n  source: unknown\n): source is DeepPartial<Target> {\n  if (isPrimitive(source)) return false;\n\n  const keys = Object.keys(source);\n\n  for (let index = 0; index < keys.length; index++) {\n    if (!(keys[index] in target)) return false;\n  }\n\n  return true;\n}\n","import type { Combine } from \"@/create-store/types/combine\";\nimport type { Dictionary } from \"@/create-store/types/dictionary\";\nimport type { Replace } from \"@/create-store/types/replace\";\n\nimport { isDictionary } from \"@/create-store/functions/assertions/is-dictionary\";\nimport { isPrimitive } from \"@/create-store/functions/assertions/is-primitive\";\nimport { clone } from \"@/create-store/functions/helpers/clone\";\n\n/**\n * A simple and straightforward deep merge function that recursively merges objects.\n * Handles cyclic references to prevent infinite recursion.\n *\n * @param target The target object that will receive the merged values\n * @param source The source object to merge into the target\n *\n * @returns A new merged object without modifying any of the inputs\n */\nexport function combine<Target extends Dictionary, Source extends Dictionary>(\n  target: Target,\n  source?: Source,\n  cache?: WeakMap<object, object>\n): Source extends Dictionary ? Replace<Target, Source> : Target;\n\n/**\n * A simple and straightforward deep merge function that recursively merges objects.\n * Handles cyclic references to prevent infinite recursion.\n *\n * @param target The target object that will receive the merged values\n * @param sources An array of source objects to merge into the target\n *\n * @returns A new merged object without modifying any of the inputs\n */\nexport function combine<\n  Target extends Dictionary,\n  Sources extends Dictionary[],\n>(\n  target: Target,\n  sources: Sources,\n  cache?: WeakMap<object, object>\n): Combine<Target, Sources>;\n\nexport function combine<\n  Target extends Dictionary,\n  Source extends Dictionary | Dictionary[],\n>(target: Target, source?: Source, cache = new WeakMap()) {\n  if (Array.isArray(source)) {\n    let result: any = target;\n    for (let index = 0; index < source.length; index++) {\n      result = combine(result, source[index], cache);\n    }\n    return result;\n  }\n\n  if (isPrimitive(source) || !isDictionary(source)) {\n    return source;\n  }\n\n  if (cache.has(target)) return cache.get(target);\n\n  const result = clone(target, cache);\n  cache.set(target, result);\n\n  const properties = Object.getOwnPropertyNames(source);\n  const symbols = Object.getOwnPropertySymbols(source);\n\n  copyProperties(result, properties, source, cache);\n  copyProperties(result, symbols, source, cache);\n\n  return result;\n}\n\n/**\n * Copies properties from the source dictionary to the result dictionary.\n * If a property in the result is a non-dictionary, it is replaced with the source value.\n * If it is a dictionary, it is combined with the source value.\n *\n * @param result The target dictionary to copy properties into\n * @param keys The keys to copy from the source dictionary\n * @param source The source dictionary from which to copy properties\n * @param cache A WeakMap to track cache objects for cyclic references\n */\nexport function copyProperties(\n  result: Dictionary,\n  keys: Array<PropertyKey>,\n  source: Dictionary,\n  cache: WeakMap<object, object>\n): void {\n  for (let index = 0; index < keys.length; index++) {\n    const key = keys[index];\n\n    const targetValue = result[key];\n    const sourceValue = source[key];\n\n    if (isDictionary(targetValue) && isDictionary(sourceValue)) {\n      result[key] = combine(targetValue, sourceValue, cache);\n    } else result[key] = sourceValue;\n  }\n}\n","import { isDictionary } from \"@/create-store/functions/assertions/is-dictionary\";\nimport { isDictionarySlice } from \"@/create-store/functions/assertions/is-dictionary-slice\";\nimport { combine } from \"@/create-store/functions/helpers/combine\";\n\nexport function replace<Target>(target: Target, source: unknown): Target {\n  if (isDictionary(target)) {\n    if (isDictionarySlice(target, source)) {\n      return combine(target, source) as Target;\n    }\n  }\n\n  return source as Target;\n}\n","import type { Split } from \"@/create-store/types/split\";\n\nexport function splitPath<Path extends string>(path: Path = \"\" as Path) {\n  return path.split(\".\") as Split<Path>;\n}\n","import type { DependencyList } from \"react\";\n\nimport type { SyncFunction } from \"@/create-store/types/sync-function\";\n\nimport { useMemo } from \"react\";\n\nimport { useVersion } from \"@/create-store/functions/hooks/use-version\";\n\n/**\n * A custom hook that computes data synchronously based on a factory function and optional dependencies.\n *\n * @param factory A function that produces the synchronous data.\n * @param dependencies An optional list of dependencies that, when changed, will trigger a re-computation of the data.\n *\n * @returns The computed data from the factory function.\n */\nexport function useSync<Data>(\n  factory: SyncFunction<Data>,\n  dependencies: DependencyList = []\n): Data {\n  const version = useVersion(dependencies);\n  return useMemo(factory, [version]);\n}\n","import { useRef } from \"react\";\n\nimport { compare } from \"@/create-store/functions/helpers/compare\";\n\n/**\n * A custom hook that compares dependencies and returns a version number.\n * The version number increments only when the dependencies change.\n *\n * @param input The input value to compare against the previous value.\n * If not provided, it defaults to `undefined`.\n *\n * @returns An array containing the current version number.\n */\nexport function useVersion(input?: unknown): number {\n  const ref = useRef<unknown>();\n  const version = useRef(0);\n\n  if (!compare(ref.current, input)) {\n    ref.current = input;\n    version.current += 1;\n  }\n\n  return version.current;\n}\n","/**\n * A radix quicksort implementation for sorting strings based on character codes.\n * It sorts strings lexicographically by their characters at a given depth.\n *\n * @param strings The array of strings to sort.\n * @param low The starting index of the subarray to sort.\n * @param high The ending index of the subarray to sort.\n * @param depth The current character position to compare in the strings.\n */\nexport function sort(\n  strings: string[],\n  low = 0,\n  high = strings.length - 1,\n  depth = 0\n): void {\n  if (low >= high) return;\n\n  let gt = high,\n    lt = low;\n\n  const pivot = charAt(strings[low], depth);\n  let index = low + 1;\n\n  while (index <= gt) {\n    const t = charAt(strings[index], depth);\n    if (t < pivot) {\n      [strings[lt], strings[index]] = [strings[index], strings[lt]];\n      lt++;\n      index++;\n    } else if (t > pivot) {\n      [strings[index], strings[gt]] = [strings[gt], strings[index]];\n      gt--;\n    } else {\n      index++;\n    }\n  }\n\n  sort(strings, low, lt - 1, depth);\n  if (pivot >= 0) sort(strings, lt, gt, depth + 1);\n  sort(strings, gt + 1, high, depth);\n}\n\nfunction charAt(str: string, pos: number): number {\n  return pos < str.length ? str.charCodeAt(pos) : -1;\n}\n","import type { Dictionary } from \"@/create-store/types/dictionary\";\n\nimport { sort } from \"@/create-store/functions/helpers/sort\";\n\n/**\n * Stringifies a value into a string representation.\n *\n * This function handles various data types including primitives, objects, arrays, sets, maps,\n * circular references, and special objects like Date, RegExp, and Error.\n *\n * @param value The value to stringify.\n * @returns A string representation of the value.\n */\nexport function stringify(value: unknown): string {\n  const circularMap = new Map<object, string>();\n  let refCounter = 0;\n\n  function format(value: unknown): string {\n    switch (typeof value) {\n      case \"bigint\":\n      case \"boolean\":\n      case \"symbol\":\n        return String(value);\n      case \"function\":\n        return `Function(${value.toString().replace(/\\s+/g, \" \")})`;\n      case \"number\":\n        return Object.is(value, -0) ? \"-0\" : String(value);\n      case \"string\":\n        return `\"${value.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, '\\\\\"')}\"`;\n      case \"undefined\":\n        return \"undefined\";\n    }\n\n    if (value === null) return \"null\";\n\n    if (typeof value === \"object\") {\n      if (circularMap.has(value)) {\n        return `[Circular:${circularMap.get(value)}]`;\n      }\n\n      const refId = `ref_${++refCounter}`;\n      circularMap.set(value, refId);\n\n      if (value instanceof Date) {\n        return `Date(\"${value.toISOString()}\")`;\n      }\n\n      if (value instanceof RegExp) {\n        return value.toString();\n      }\n\n      if (value instanceof Error) {\n        return `Error(\"${value.message}\")`;\n      }\n\n      if (value instanceof Set) {\n        if (!value.size) return \"Set()\";\n\n        const elements: string[] = [];\n        for (const item of value) {\n          elements.push(format(item));\n        }\n        sort(elements);\n\n        let result = \"Set([\";\n        for (let index = 0; index < elements.length; index++) {\n          if (index > 0) result += \",\";\n          result += elements[index];\n        }\n        return result + \"])\";\n      }\n\n      if (value instanceof Map) {\n        if (!value.size) return \"Map()\";\n\n        const entries: string[] = [];\n        for (const [key, item] of value) {\n          entries.push(`[${format(key)},${format(item)}]`);\n        }\n        sort(entries);\n\n        let result = \"Map([\";\n        for (let index = 0; index < entries.length; index++) {\n          if (index > 0) result += \",\";\n          result += entries[index];\n        }\n        return result + \"])\";\n      }\n\n      if (Array.isArray(value)) {\n        if (!value.length) return \"[]\";\n\n        const entries: string[] = [];\n        for (let index = 0; index < value.length; index++) {\n          entries.push(format(value[index]));\n        }\n        sort(entries);\n\n        let result = \"[\";\n        for (let index = 0; index < entries.length; index++) {\n          if (index > 0) result += \",\";\n          result += entries[index];\n        }\n        return result + \"]\";\n      }\n\n      isDictionary(value);\n      const keys = Object.keys(value);\n      if (!keys.length) return \"{}\";\n\n      const properties: string[] = [];\n      for (let index = 0; index < keys.length; index++) {\n        const key = keys[index];\n        properties.push(`${key}:${format(value[key])}`);\n      }\n      sort(properties);\n\n      let result = \"{\";\n      for (let index = 0; index < properties.length; index++) {\n        if (index > 0) result += \",\";\n        result += properties[index];\n      }\n      return result + \"}\";\n    }\n\n    return String(value);\n  }\n\n  const result = format(value);\n  circularMap.clear();\n  return result;\n}\n\nfunction isDictionary(value: unknown): asserts value is Dictionary {\n  if (typeof value !== \"object\") throw new TypeError(\"Should be an object\");\n}\n","import { stringify } from \"../stringify\";\n\nexport function compare(left?: unknown, right?: unknown): boolean {\n  if (left === right) return true;\n  if (!left || !right) return false;\n\n  if (typeof left !== typeof right) return false;\n  if (typeof left !== \"object\") return left === right;\n\n  return stringify(left) === stringify(right);\n}\n","import type { Dictionary } from \"@/create-store/types/dictionary\";\nimport type { Paths } from \"@/create-store/types/paths\";\nimport type { ResolvePath } from \"@/create-store/types/resolve-path\";\n\nimport { isDictionary } from \"@/create-store/functions/assertions/is-dictionary\";\nimport { splitPath } from \"@/create-store/functions/helpers/split-path\";\n\n/**\n * Resolves a path in a given state object and returns the value at that path.\n *\n * @description\n * This function takes a state object and a path, which can be a string or an array of strings,\n * and traverses the state object to find the value at the specified path. If the path does not exist,\n * it returns undefined. If no path is provided, it returns the entire state object.\n *\n * @param state The state object to resolve the path in.\n * @param path The path to resolve, represented as a string or an array of strings.\n *\n * @returns The value at the resolved path, or undefined if the path does not exist.\n */\nexport function resolvePath<\n  State extends Dictionary,\n  Path extends Paths<State> = never,\n>(state: State, path?: Path): ResolvePath<State, Path> {\n  if (!path) return state as ResolvePath<State, Path>;\n\n  const segments = splitPath(path);\n  let current: any = state;\n\n  for (const key of segments) {\n    if (!isDictionary(current) || !(key in current)) {\n      return undefined as ResolvePath<State, Path>;\n    }\n    current = current[key];\n  }\n\n  return current as ResolvePath<State, Path>;\n}\n","import type { Selector } from \"@/create-store/types/selector\";\n\nimport { isFunction } from \"@/create-store/functions/assertions/is-function\";\nimport { clone } from \"@/create-store/functions/helpers/clone\";\n\nexport function resolveSelectorValue<State, Value = State>(\n  state: State,\n  selector?: Selector<State, Value>,\n  cache?: WeakMap<object, any>\n) {\n  const value = clone(state, cache);\n  if (isFunction(selector)) return selector(value);\n  return value as unknown as Value;\n}\n","import type { DependencyList } from \"react\";\n\nimport type { PartialStateManager } from \"@/create-store/types/partial-state-manager\";\nimport type { PrimitiveStore } from \"@/create-store/types/primitive-store\";\nimport type { Selector } from \"@/create-store/types/selector\";\nimport type { SetPartialStateAction } from \"@/create-store/types/set-partial-state-action\";\nimport type { Subscriber } from \"@/create-store/types/subscriber\";\n\nimport { useSyncExternalStore } from \"react\";\n\nimport { isAccessor } from \"@/create-store/functions/assertions/is-accessor\";\nimport { isDictionary } from \"@/create-store/functions/assertions/is-dictionary\";\nimport { isSetStateActionFunction } from \"@/create-store/functions/assertions/is-set-state-action-function\";\nimport { clone } from \"@/create-store/functions/helpers/clone\";\nimport { replace } from \"@/create-store/functions/helpers/replace\";\nimport { useSync } from \"@/create-store/functions/hooks/use-sync\";\nimport { resolveSelectorValue } from \"@/create-store/functions/utilities/resolve-selector-value\";\n\nexport function createPrimitiveStore<State>(\n  initialState: State\n): PrimitiveStore<State> {\n  let state = initialState;\n  const subscribers = new Set<Subscriber<State>>();\n  const cache = new WeakMap<object, any>();\n\n  function setState(value: State) {\n    state = value;\n    notifySubscribers(value);\n    return true;\n  }\n\n  function notifySubscribers(value: State) {\n    subscribers.forEach((subscriber) => subscriber(value));\n  }\n\n  function buildStore() {\n    function $get<Value = State>(selector?: Selector<State, Value>) {\n      return resolveSelectorValue(state, selector, cache);\n    }\n\n    function $set(action: SetPartialStateAction<State>) {\n      const next = isSetStateActionFunction<State>(action)\n        ? action(clone(state, cache))\n        : action;\n      setState(replace(state, next));\n    }\n\n    function $use<Value = State>(\n      selector?: Selector<State, Value>,\n      dependencies?: DependencyList\n    ): PartialStateManager<State, Value> {\n      const value = useSyncExternalStore($act, $get, $get);\n      const resolvedValue = useSync(() => {\n        return resolveSelectorValue(value, selector);\n      }, [value, dependencies]);\n\n      return [resolvedValue, $set];\n    }\n\n    function $act(subscriber: Subscriber<State>, immediate = true) {\n      subscribers.add(subscriber);\n      if (immediate) subscriber(state);\n\n      return () => {\n        subscribers.delete(subscriber);\n      };\n    }\n\n    return {\n      $act,\n      $get,\n      $set,\n      $use,\n    };\n  }\n\n  const node = buildStore() as PrimitiveStore<State>;\n\n  return new Proxy(node, {\n    defineProperty() {\n      return true;\n    },\n\n    deleteProperty() {\n      return true;\n    },\n\n    get(target, prop) {\n      if (isAccessor(target, prop)) return target[prop];\n      return undefined;\n    },\n\n    getOwnPropertyDescriptor(target, prop) {\n      if (isAccessor(target, prop)) {\n        return {\n          configurable: true,\n          enumerable: false,\n          value: target[prop],\n          writable: false,\n        };\n      }\n      return undefined;\n    },\n\n    has(target, prop) {\n      return isAccessor(target, prop);\n    },\n\n    ownKeys() {\n      return isDictionary(state) ? Reflect.ownKeys(state) : [];\n    },\n\n    set() {\n      return true;\n    },\n  });\n}\n","import type { Factory } from \"@/create-store/types/factory\";\nimport type { Possible } from \"@/create-store/types/possible\";\n\nimport { isFunction } from \"@/create-store/functions/assertions/is-function\";\n\nexport function resolveValue<State>(\n  initialState?: Possible<Factory<State | undefined>>\n): State {\n  if (isFunction<State>(initialState)) return initialState();\n  return initialState as State;\n}\n","import type { CompositeStore } from \"@/create-store/types/composite-store\";\nimport type { Dictionary } from \"@/create-store/types/dictionary\";\nimport type { Factory } from \"@/create-store/types/factory\";\nimport type { Initializer } from \"@/create-store/types/initializer\";\nimport type { Possible } from \"@/create-store/types/possible\";\nimport type { PrimitiveStore } from \"@/create-store/types/primitive-store\";\n\nimport { isDictionary } from \"@/create-store/functions/assertions/is-dictionary\";\nimport { isPromise } from \"@/create-store/functions/assertions/is-promise\";\nimport { createCompositeStore } from \"@/create-store/functions/library/create-composite-store\";\nimport { createPrimitiveStore } from \"@/create-store/functions/library/create-primitive-store\";\nimport { resolveValue } from \"@/create-store/functions/utilities/resolve-value\";\n\n/**\n * @example\n *\n * const count = createStore({\n *   value: 0,\n *   increase(amount: number = 1) {\n *     count.value.$set((state) => state + amount);\n *   },\n *   decrease(amount: number = 1) {\n *     count.value.$set((state) => state - amount);\n *   },\n * });\n *\n * count.increase(4);\n */\nexport function createStore<State extends Dictionary>(\n  state: Factory<State>\n): CompositeStore<State>;\n\n/**\n * @example\n *\n * const fetchCount = async () => {\n *  const result = await fetch(\"https://api.example.com/count\");\n *  const data = await result.json();\n *  return data.count;\n * };\n *\n * const count = await createStore(fetchCount);\n * count.$act((state) => console.log(state));\n * count.$set(78);\n */\nexport function createStore<State>(\n  state: Initializer<Promise<State>>\n): Promise<PrimitiveStore<State>>;\n\n/**\n * @example\n *\n * const count = createStore(0);\n * count.$get(); // 0\n */\nexport function createStore<State>(\n  state: Factory<State>\n): PrimitiveStore<State>;\n\n/**\n * @example\n *\n * const count = createStore<number>();\n */\nexport function createStore<State>(\n  state?: Possible<Factory<State | undefined>>\n): PrimitiveStore<State | undefined>;\n\nexport function createStore<State>(initialState?: State) {\n  const state = resolveValue(initialState);\n\n  if (isPromise<State>(state)) {\n    return state.then((resolved) => createPrimitiveStore(resolved));\n  }\n\n  if (isDictionary(state)) {\n    return createCompositeStore(state);\n  }\n\n  return createPrimitiveStore(state);\n}\n","export function isNullish<T>(value?: null | T): value is null | undefined {\n  return value === null || value === undefined;\n}\n","import type {\n  AsyncBrowserStorageAdapterOptions,\n  AsyncGetBrowserStorage,\n  AsyncSetBrowserStorage,\n} from \"@/create-store/types/async-browser-storage-adapter\";\n\nimport { isNullish } from \"@/create-store/functions/assertions/is-nullish\";\n\nexport function createAsyncBrowserStorageAdapter<State, StoredState = State>(\n  key: string,\n  {\n    beforeStorage = (value: State) => value as unknown as StoredState,\n    beforeUsage = (value: StoredState) => value as unknown as State,\n    getItem,\n    removeItem,\n    setItem,\n  }: AsyncBrowserStorageAdapterOptions<State, StoredState>\n): [\n  getStorageState: AsyncGetBrowserStorage<State>,\n  setStorageState: AsyncSetBrowserStorage<State>,\n] {\n  async function getStorageState(fallback: State): Promise<State>;\n  async function getStorageState(fallback?: State): Promise<State | undefined>;\n\n  async function getStorageState(fallback?: State): Promise<State | undefined> {\n    const value = await getItem(key);\n    if (isNullish(value)) return fallback;\n    return beforeUsage(value);\n  }\n\n  async function setStorageState(value?: State): Promise<void> {\n    if (value === undefined) return removeItem(key);\n    const transformedValue = beforeStorage(value);\n    await setItem(key, transformedValue);\n  }\n\n  return [getStorageState, setStorageState];\n}\n","/**\n * Safely converts a value to a string.\n *\n * @description\n * If the value is already a string, it will return the value as is.\n *\n * @param value The value to convert to a string.\n * @returns The value as a string.\n */\nexport function safeStringify<ValueType = unknown>(value: ValueType): string {\n  if (typeof value === \"string\") return value;\n  return JSON.stringify(value);\n}\n","/**\n * @template ReturnType\n *\n * @description\n * If the value is a string, it will attempt to parse it as JSON. If it fails, it will return the value as is.\n *\n * @param value The value to parse.\n * @returns The parsed value.\n */\nexport function tryParse<ReturnType>(value: string): ReturnType {\n  try {\n    return JSON.parse(value);\n  } catch {\n    return value as ReturnType;\n  }\n}\n","import type {\n  BrowserStorageAdapterOptions,\n  GetBrowserStorage,\n  SetBrowserStorage,\n} from \"@/create-store/types/browser-storage-adapter\";\n\nimport { isNullish } from \"@/create-store/functions/assertions/is-nullish\";\nimport { safeStringify } from \"@/create-store/functions/utilities/safe-stringify\";\nimport { tryParse } from \"@/create-store/functions/utilities/try-parse\";\n\nexport function createBrowserStorageAdapter<State>(\n  key: string,\n  {\n    getItem,\n    parse = tryParse,\n    removeItem,\n    setItem,\n    stringify = safeStringify,\n  }: BrowserStorageAdapterOptions<State>\n): [\n  getStorageState: GetBrowserStorage<State>,\n  setStorageState: SetBrowserStorage<State>,\n] {\n  function getStorageState(fallback: State): State;\n  function getStorageState(fallback?: State): State | undefined;\n\n  function getStorageState(fallback?: State) {\n    const value = getItem(key);\n    if (isNullish(value)) return fallback;\n    return parse(value);\n  }\n\n  const setStorageState = (value?: State) => {\n    if (value === undefined) return removeItem(key);\n    const serializedValue = stringify(value);\n    setItem(key, serializedValue);\n  };\n\n  return [getStorageState, setStorageState];\n}\n","import type { Dictionary } from \"@/create-store/types/dictionary\";\nimport type { Merge } from \"@/create-store/types/merge\";\n\n/**\n * Merges two objects into a new object.\n *\n * @param target The target object that will receive the merged values\n * @param source The source object to merge into the target\n *\n * @returns A new merged object without modifying any of the inputs\n */\nexport function merge<Target extends Dictionary, Source>(\n  target: Target,\n  source: Source\n): Merge<Target, Source> {\n  return Object.defineProperties(\n    target,\n    Object.getOwnPropertyDescriptors(source)\n  ) as Merge<Target, Source>;\n}\n","import type { CookieOptions } from \"@/cookie-storage/types/cookie-options\";\nimport type {\n  CookieStorageAdapterOptions,\n  GetCookieStorage,\n  SetCookieStorage,\n} from \"@/create-store/types/cookie-storage\";\n\nimport { cookieStorage } from \"@/cookie-storage\";\nimport { isNullish } from \"@/create-store/functions/assertions/is-nullish\";\nimport { merge } from \"@/create-store/functions/helpers/merge\";\nimport { safeStringify } from \"@/create-store/functions/utilities/safe-stringify\";\nimport { tryParse } from \"@/create-store/functions/utilities/try-parse\";\n\nexport function createCookieStorageAdapter<State>(\n  key: string,\n  {\n    parse = tryParse,\n    secret,\n    signed = false,\n    stringify = safeStringify,\n    ...cookieOptions\n  }: CookieStorageAdapterOptions<State> = {} as CookieStorageAdapterOptions<State>\n): [\n  getCookieStorageState: GetCookieStorage<State>,\n  setCookieStorageState: SetCookieStorage<State>,\n] {\n  const cookieOptionsMap = new Map<string, CookieOptions>();\n\n  const retrieveCookieOptions = (key: string): CookieOptions => {\n    const options = cookieOptionsMap.get(key);\n    if (options) return options;\n    return cookieOptions;\n  };\n\n  function getCookieStorageState(): State | undefined;\n  function getCookieStorageState(fallback: State): State;\n\n  function getCookieStorageState(fallback?: State) {\n    const value = cookieStorage.getItem(key);\n    if (isNullish(value)) return fallback as State;\n\n    if (secret) {\n      const parsedValue = cookieStorage.unsign(value, secret);\n      if (parsedValue) return parse(parsedValue);\n    }\n\n    return parse(value);\n  }\n\n  const setCookieStorageState = (\n    value?: State,\n    options: CookieOptions = {}\n  ) => {\n    if (value === undefined) return cookieStorage.removeItem(key);\n\n    const previousOptions = retrieveCookieOptions(key);\n    const mergedOptions = merge(previousOptions, options);\n    const serializedValue = stringify(value);\n\n    if (secret) {\n      const hashedCookieData = cookieStorage.sign(serializedValue, secret);\n      cookieStorage.setItem(key, hashedCookieData, mergedOptions);\n    } else cookieStorage.setItem(key, serializedValue, mergedOptions);\n\n    cookieOptionsMap.set(key, mergedOptions);\n  };\n\n  return [getCookieStorageState, setCookieStorageState];\n}\n","import type {\n  GetLocalStorage,\n  SetLocalStorage,\n} from \"@/create-store/types/local-storage\";\nimport type { StorageAdapterOptions } from \"@/create-store/types/storage-adapter\";\n\nimport { safeStringify } from \"@/create-store/functions/utilities/safe-stringify\";\nimport { tryParse } from \"@/create-store/functions/utilities/try-parse\";\n\nexport function createLocalStorageAdapter<State>(\n  key: string,\n  {\n    parse = tryParse,\n    stringify = safeStringify,\n  }: StorageAdapterOptions<State> = {}\n): [\n  getLocalStorageState: GetLocalStorage<State>,\n  setLocalStorageState: SetLocalStorage<State>,\n] {\n  function getLocalStorageState(): State | undefined;\n  function getLocalStorageState(fallback: State): State;\n\n  function getLocalStorageState(fallback?: State) {\n    if (typeof localStorage === \"undefined\") return fallback;\n\n    const value = localStorage.getItem(key);\n    if (value) return parse(value);\n\n    return fallback;\n  }\n\n  const setLocalStorageState = (value?: State) => {\n    if (typeof localStorage === \"undefined\") return;\n    if (value === undefined) return localStorage.removeItem(key);\n\n    const serializedValue = stringify(value);\n    localStorage.setItem(key, serializedValue);\n  };\n\n  return [getLocalStorageState, setLocalStorageState];\n}\n","import type {\n  GetSessionStorage,\n  SetSessionStorage,\n} from \"@/create-store/types/session-storage\";\nimport type { StorageAdapterOptions } from \"@/create-store/types/storage-adapter\";\n\nimport { safeStringify } from \"@/create-store/functions/utilities/safe-stringify\";\nimport { tryParse } from \"@/create-store/functions/utilities/try-parse\";\n\nexport function createSessionStorageAdapter<State>(\n  key: string,\n  {\n    parse = tryParse,\n    stringify = safeStringify,\n  }: StorageAdapterOptions<State> = {}\n): [\n  getSessionStorageState: GetSessionStorage<State>,\n  setSessionStorageState: SetSessionStorage<State>,\n] {\n  function getSessionStorageState(): State | undefined;\n  function getSessionStorageState(fallback: State): State;\n\n  function getSessionStorageState(fallback?: State) {\n    if (typeof sessionStorage === \"undefined\") return fallback;\n\n    const value = sessionStorage.getItem(key);\n    if (value) return parse(value);\n\n    return fallback;\n  }\n\n  const setSessionStorageState = (value?: State) => {\n    if (typeof sessionStorage === \"undefined\") return;\n    if (value === undefined) return sessionStorage.removeItem(key);\n\n    const serializedValue = stringify(value);\n    sessionStorage.setItem(key, serializedValue);\n  };\n\n  return [getSessionStorageState, setSessionStorageState];\n}\n","import type { DependencyList } from \"react\";\n\nimport type { AsyncFunction } from \"@/create-store/types/async-function\";\nimport type { AsyncState } from \"@/create-store/types/async-state\";\n\nimport { useEffect, useReducer } from \"react\";\n\nimport { useVersion } from \"@/create-store/functions/hooks/use-version\";\n\nimport { reducer } from \"./reducer\";\n\n/**\n * A custom hook for handling asynchronous effects with loading, error, and data states.\n *\n * @param effect The async function to execute\n * @param dependencies Dependencies array to trigger re-execution\n *\n * @returns An object containing data, loading, error states and an execute function\n */\nexport function useAsync<Data>(\n  effect: AsyncFunction<Data>,\n  dependencies: DependencyList = []\n): AsyncState<Data> {\n  const version = useVersion(dependencies);\n\n  const [state, dispatch] = useReducer(reducer<Data>, {\n    data: null,\n    error: null,\n    isLoading: true,\n  });\n\n  useEffect(() => {\n    const controller = new AbortController();\n    const signal = controller.signal;\n\n    dispatch({ type: \"LOADING\" });\n\n    effect(controller)\n      .then((payload) => {\n        if (!signal.aborted) {\n          dispatch({ payload, type: \"SUCCESS\" });\n        }\n      })\n      .catch((error) => {\n        if (!signal.aborted) {\n          const isError = error instanceof Error;\n          const payload = isError ? error : new Error(String(error));\n          dispatch({ payload, type: \"ERROR\" });\n        }\n      });\n\n    return () => {\n      controller.abort();\n    };\n  }, [version]);\n\n  return state;\n}\n","import type { AsyncAction } from \"@/create-store/types/async-action\";\nimport type { AsyncState } from \"@/create-store/types/async-state\";\n\nexport function reducer<Data>(\n  state: AsyncState<Data>,\n  action: AsyncAction<Data>\n): AsyncState<Data> {\n  switch (action.type) {\n    case \"ERROR\": {\n      const error = action.payload;\n      return { data: null, error, isLoading: false };\n    }\n    case \"LOADING\": {\n      return { data: null, error: null, isLoading: true };\n    }\n    case \"SUCCESS\": {\n      const data = action.payload;\n      return { data, error: null, isLoading: false };\n    }\n    default:\n      return state;\n  }\n}\n","import type { PropsWithChildren } from \"react\";\n\nimport type { ContextStore } from \"@/create-store/types/context-store\";\nimport type { ContextValue } from \"@/create-store/types/context-value\";\n\nimport { createContext, useContext } from \"react\";\n\n/**\n * Initializes a context store with a provider and a hook for accessing its value.\n *\n * @param use A hook function that generates the store from the given context.\n * @returns A tuple with the StoreProvider component and the useStore hook.\n */\nexport function createContextStore<Context, Store>(\n  use: ContextValue<Context, Store>\n): ContextStore<Context, Store> {\n  const StoreContext = createContext<null | Store>(null);\n  StoreContext.displayName = \"StoreContext\";\n\n  function StoreProvider({\n    children,\n    value,\n  }: PropsWithChildren<{ value: Context }>) {\n    const store = use(value);\n    return (\n      <StoreContext.Provider value={store}>{children}</StoreContext.Provider>\n    );\n  }\n\n  function useStore(): Store {\n    const store = useContext(StoreContext);\n\n    if (store === null) {\n      throw new Error(\n        `Make sure your component is wrapped in <${StoreContext.displayName}.Provider>`\n      );\n    }\n\n    return store;\n  }\n\n  return [StoreProvider, useStore];\n}\n","import type { GenericObject } from \"@/create-store/types/generic-object\";\n\n/**\n * Check if the value is a plain object.\n *\n * @param value The value to check.\n * @returns A boolean indicating whether the value is a plain object.\n */\nexport function isObject(value: unknown): value is GenericObject {\n  return typeof value === \"object\" && value !== null;\n}\n","import type { Dictionary } from \"@/create-store/types/dictionary\";\nimport type { GenericObject } from \"@/create-store/types/generic-object\";\nimport type { Normalize } from \"@/create-store/types/normalize\";\n\nimport { isDictionary } from \"@/create-store/functions/assertions/is-dictionary\";\nimport { isObject } from \"@/create-store/functions/assertions/is-object\";\n\nexport function normalizeObject<State extends GenericObject>(\n  state: State\n): Normalize<State> {\n  if (!isObject(state)) {\n    throw new Error(\"State must be an object\");\n  }\n\n  return normalizeValue(state) as Normalize<State>;\n}\n\nfunction normalizeValue<State extends Dictionary>(\n  state: State,\n  seen = new WeakMap()\n): Partial<State> {\n  if (seen.has(state)) {\n    return seen.get(state) as Partial<State>;\n  }\n\n  const normalizedState: Partial<State> = {};\n\n  seen.set(state, normalizedState);\n\n  for (const key of Reflect.ownKeys(state)) {\n    try {\n      if (typeof key === \"symbol\") {\n        continue;\n      }\n\n      const value = Reflect.get(state, key);\n\n      if (typeof value === \"function\") {\n        continue;\n      }\n\n      if (!isDictionary(value)) {\n        Reflect.set(normalizedState, key, value);\n        continue;\n      }\n\n      const normalizedValue = normalizeValue(value, seen);\n      Reflect.set(normalizedState, key, normalizedValue);\n    } catch {\n      continue;\n    }\n  }\n\n  return normalizedState as Normalize<State>;\n}\n"],"mappings":"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","names":["index_exports","__export","combine","cookieStorage","createAsyncBrowserStorageAdapter","createBrowserStorageAdapter","createCompositeStore","createContextStore","createCookieStorageAdapter","createLocalStorageAdapter","createPrimitiveStore","createSessionStorageAdapter","createStore","normalizeObject","useAsync","useSync","useVersion","__toCommonJS","isEnabled","value","formatCookieOptions","path","options","cookieOptions","domain","expires","httpOnly","maxAge","partitioned","sameSite","secure","isEnabled","expiresDate","setCookieValue","name","value","options","cookieOptionsString","formatCookieOptions","error","removeCookieValue","name","path","setCookieValue","error","clearCookieStorage","cookie","name","removeCookieValue","error","createCustomWordPattern","word","length","consonants","vowels","vowelsLookup","letters","words","char","index","iterator","character","idx","factor","join","segments","connector","transformCase","text","caseType","_","char","createCookieKey","cookieFragmentDescription","cookieFragmentsConnector","cookieFragmentSizes","cookiePrefix","cookieScope","cookieScopeCase","cookieScopeFragmentConnector","cookieScopeServiceConnector","cookieService","cookieSuffix","words","size","fragments","word","index","length","createCustomWordPattern","transformCase","scope","join","service","description","name","getCookieByIndex","index","cookie","name","error","getCookieStorageLength","cookie","error","getCookieValue","name","cookies","index","cookieAtIndex","cookie","error","M","BLOCK_SIZE","LITTLE_ENDIAN","convertEndian","word","getFractionalBits","n","rightRotate","bits","DEFAULT_STATE","state","nPrime","isPrime","i","ROUND_CONSTANTS","constants","Hmac","key","toUint8Array","SHA256","tmp","encoding","msg","sum","a","offset","chunk","oKeyPad","iKeyPad","inner","concat","result","toHex","toBase64","data","bitLength","paddedLength","buffer","words","w","t","s0","s1","b","c","d","e","f","g","h","S1","ch","temp1","S0","maj","temp2","res","buf","input","createHmac","algorithm","signCookie","cookie","secret","signature","createHmac","error","constantTimeCompare","a","b","result","index","unsignCookie","signedCookie","secret","demarcator","cookie","expectedSignature","signCookie","constantTimeCompare","error","cookieStorage","clearCookieStorage","createCookieKey","getCookieValue","getCookieByIndex","getCookieStorageLength","removeCookieValue","setCookieValue","signCookie","unsignCookie","isDictionary","value","isPromise","state","import_react","isAccessor","target","prop","isFunction","value","isSetStateActionFunction","value","CloneRegistry","value","constructor","getConstructor","handler","validator","Validators","result","Handlers","visited","clone","length","key","createAsyncInstance","createAsyncGeneratorInstance","Constructor","item","createInstance","createGeneratorInstance","resolve","reject","resolved","error","createCloneFunction","registryModifier","registry","createDefaultRegistry","isPrimitive","copyProperties","args","instance","generator","isNonObject","method","registerFunctionConstructors","registerTypedArrayConstructors","registerWeakCollections","type","isPropertyAccessor","descriptor","AsyncGeneratorFunction","GeneratorFunction","AsyncFunction","copyProperties","result","value","visited","clone","properties","index","key","descriptor","isPropertyAccessor","symbols","clone","b","registry","c","createPathComponents","path","segments","result","current","index","createPaths","store","prefix","visited","isDictionary","paths","key","value","path","isPrimitive","value","isDictionarySlice","target","source","isPrimitive","keys","index","combine","target","source","cache","result","index","isPrimitive","isDictionary","clone","properties","symbols","copyProperties","keys","key","targetValue","sourceValue","replace","target","source","isDictionary","isDictionarySlice","combine","splitPath","path","import_react","import_react","sort","strings","low","high","depth","gt","lt","pivot","charAt","index","t","str","pos","stringify","value","circularMap","refCounter","format","refId","elements","item","sort","result","index","entries","key","isDictionary","keys","properties","compare","left","right","stringify","useVersion","input","ref","version","compare","useSync","factory","dependencies","version","useVersion","resolvePath","state","path","segments","splitPath","current","key","isDictionary","resolveSelectorValue","state","selector","cache","value","clone","isFunction","createCompositeStore","initialState","state","cache","originalPaths","trackOriginalPaths","obj","currentPath","visited","isDictionary","key","fullPath","subscribers","getSubscribersByPath","path","notifySubscribers","resolvedValue","resolvePath","valuePaths","createPaths","pathComponents","createPathComponents","paths","set","pathKey","subscriber","setState","value","setProperty","keys","splitPath","snapshot","clone","pivot","current","get","selector","resolveSelectorValue","action","next","isSetStateActionFunction","replace","act","immediate","createSubscribe","callback","use","dependencies","getSnapshot","subscribe","setter","useSync","joinPaths","basePath","property","resolveProperty","isFunction","createProxy","buildStore","chain","node","proxy","target","prop","isAccessor","import_react","createPrimitiveStore","initialState","state","subscribers","cache","setState","value","notifySubscribers","subscriber","buildStore","$get","selector","resolveSelectorValue","$set","action","next","isSetStateActionFunction","clone","replace","$use","dependencies","$act","useSync","immediate","node","target","prop","isAccessor","isDictionary","resolveValue","initialState","isFunction","createStore","initialState","state","resolveValue","isPromise","resolved","createPrimitiveStore","isDictionary","createCompositeStore","isNullish","value","createAsyncBrowserStorageAdapter","key","beforeStorage","value","beforeUsage","getItem","removeItem","setItem","getStorageState","fallback","isNullish","setStorageState","transformedValue","safeStringify","value","tryParse","value","createBrowserStorageAdapter","key","getItem","parse","tryParse","removeItem","setItem","stringify","safeStringify","getStorageState","fallback","value","isNullish","serializedValue","merge","target","source","createCookieStorageAdapter","key","parse","tryParse","secret","signed","stringify","safeStringify","cookieOptions","cookieOptionsMap","retrieveCookieOptions","options","getCookieStorageState","fallback","value","cookieStorage","isNullish","parsedValue","previousOptions","mergedOptions","merge","serializedValue","hashedCookieData","createLocalStorageAdapter","key","parse","tryParse","stringify","safeStringify","getLocalStorageState","fallback","value","serializedValue","createSessionStorageAdapter","key","parse","tryParse","stringify","safeStringify","getSessionStorageState","fallback","value","serializedValue","import_react","reducer","state","action","useAsync","effect","dependencies","version","useVersion","state","dispatch","reducer","controller","signal","payload","error","import_react","import_jsx_runtime","createContextStore","use","StoreContext","StoreProvider","children","value","store","useStore","isObject","value","normalizeObject","state","isObject","normalizeValue","seen","normalizedState","key","value","isDictionary","normalizedValue"]}