@qezor/structkit 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abdul Ahad
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,100 @@
+# @qezor/structkit
+
+`@qezor/structkit` is a focused data-manipulation toolkit for:
+- arrays
+- objects
+- path access
+- iterative deep equality
+- iterative deep merge and clone
+
+It is built to cover the high-use utility surface people often reach for in lodash, without turning into a bag of random helpers.
+
+## Install
+
+```bash
+npm install @qezor/structkit
+```
+
+## What It Prioritizes
+
+- iterative internals for deep operations
+- no callback-style APIs
+- no recursion-heavy deep walkers
+- predictable helpers for arrays, objects, and paths
+- a shared Qezor Bridge contract so other libraries can detect capabilities cleanly
+
+## Main Helpers
+
+- `toArray(value)`
+- `chunk(array, size)`
+- `compact(array)`
+- `uniq(array)`
+- `uniqBy(array, iteratee)`
+- `difference(array, values)`
+- `intersection(array, values)`
+- `partition(array, iteratee)`
+- `groupBy(array, iteratee)`
+- `countBy(array, iteratee)`
+- `keyBy(array, iteratee)`
+- `sortBy(array, iteratee)`
+- `flatMap(array, iteratee)`
+- `sumBy(array, iteratee)`
+- `tokenizePath(path)`
+- `get(value, path, defaultValue)`
+- `has(value, path)`
+- `set(value, path, nextValue)`
+- `unset(value, path)`
+- `pick(value, paths)`
+- `omit(value, paths)`
+- `mapValues(object, iteratee)`
+- `defaults(target, ...sources)`
+- `assignDefined(target, ...sources)`
+- `cloneShallow(value)`
+- `cloneDeep(value)`
+- `mergeDeep(target, ...sources)`
+- `isEqual(left, right)`
+
+## Usage
+
+```js
+const {
+  groupBy,
+  get,
+  set,
+  mergeDeep,
+  isEqual,
+} = require("@qezor/structkit")
+
+const users = [
+  { id: "u_1", role: "buyer" },
+  { id: "u_2", role: "buyer" },
+  { id: "u_3", role: "seller" },
+]
+
+const grouped = groupBy(users, "role")
+const state = {}
+
+set(state, "queue.region.city", "Pune")
+
+const region = get(state, "queue.region.city")
+const merged = mergeDeep({}, { demand: { joinedUnits: 12 } }, { demand: { buyers: 3 } })
+const same = isEqual(merged, { demand: { joinedUnits: 12, buyers: 3 } })
+```
+
+## Qezor Bridge
+
+The root export carries bridge metadata through `Symbol.for("qezor.bridge")`.
+
+That lets other Qezor libraries detect things like:
+- `structure`
+- `structure:array`
+- `structure:object`
+- `structure:path`
+- `structure:compare`
+
+## Notes
+
+- deep clone, deep merge, and deep equality use iterative walkers instead of recursion
+- arrays are replaced during `mergeDeep()` instead of element-wise merged
+- `omit()` works on cloned data, so the original input is left untouched
+- `set()` mutates the provided target, like many performance-oriented utility helpers do

package/bridge.d.ts

@@ -0,0 +1,14 @@
+export interface QezorBridge {
+  name: string
+  kind: string
+  version: string
+  capabilities: string[]
+  adapters: string[]
+  dependencies: string[]
+}
+
+export const QEZOR_BRIDGE: unique symbol
+export function createQezorBridge(input?: Partial<QezorBridge>): QezorBridge
+export function attachQezorBridge<T extends object>(target: T, input?: Partial<QezorBridge>): T
+export function readQezorBridge(target: unknown): QezorBridge | null
+export function hasQezorCapability(target: unknown, capability: string): boolean

package/bridge.js

@@ -0,0 +1,3 @@
+"use strict"
+
+module.exports = require("./lib/bridge.js")

package/bridge.mjs

@@ -0,0 +1,11 @@
+import mod from "./bridge.js"
+
+export const {
+  QEZOR_BRIDGE,
+  createQezorBridge,
+  attachQezorBridge,
+  readQezorBridge,
+  hasQezorCapability,
+} = mod
+
+export default mod

package/index.d.ts

@@ -0,0 +1,53 @@
+export type PathToken = string | number
+export type PathInput = string | number | readonly PathToken[]
+export type Iteratee<T = unknown, R = unknown> =
+  | ((value: T, indexOrKey?: number | string, collection?: unknown) => R)
+  | PathInput
+  | null
+  | undefined
+
+export interface QezorBridge {
+  name: string
+  kind: string
+  version: string
+  capabilities: string[]
+  adapters: string[]
+  dependencies: string[]
+}
+
+export const QEZOR_BRIDGE: unique symbol
+export function createQezorBridge(input?: Partial<QezorBridge>): QezorBridge
+export function attachQezorBridge<T extends object>(target: T, input?: Partial<QezorBridge>): T
+export function readQezorBridge(target: unknown): QezorBridge | null
+export function hasQezorCapability(target: unknown, capability: string): boolean
+
+export function toArray<T = unknown>(value: unknown): T[]
+export function chunk<T = unknown>(value: unknown, size?: number): T[][]
+export function compact<T = unknown>(value: unknown): T[]
+export function uniq<T = unknown>(value: unknown): T[]
+export function uniqBy<T = unknown>(value: unknown, iteratee?: Iteratee<T, unknown>): T[]
+export function difference<T = unknown>(value: unknown, values: unknown): T[]
+export function intersection<T = unknown>(value: unknown, values: unknown): T[]
+export function partition<T = unknown>(value: unknown, iteratee?: Iteratee<T, unknown>): [T[], T[]]
+export function groupBy<T = unknown>(value: unknown, iteratee?: Iteratee<T, unknown>): Record<string, T[]>
+export function countBy<T = unknown>(value: unknown, iteratee?: Iteratee<T, unknown>): Record<string, number>
+export function keyBy<T = unknown>(value: unknown, iteratee?: Iteratee<T, unknown>): Record<string, T>
+export function sortBy<T = unknown>(value: unknown, iteratee?: Iteratee<T, unknown>): T[]
+export function flatMap<T = unknown, R = unknown>(value: unknown, iteratee?: Iteratee<T, R | R[]>): R[]
+export function sumBy<T = unknown>(value: unknown, iteratee?: Iteratee<T, number>): number
+
+export function tokenizePath(path: PathInput): PathToken[]
+export function get<T = unknown>(value: unknown, path: PathInput, defaultValue?: T): T
+export function has(value: unknown, path: PathInput): boolean
+export function set<T extends object>(target: T, path: PathInput, nextValue: unknown): T
+export function unset(target: object, path: PathInput): boolean
+export function pick(value: unknown, paths: PathInput | PathInput[]): Record<string, unknown>
+export function omit<T = unknown>(value: T, paths: PathInput | PathInput[]): T
+export function mapValues<T extends Record<string, unknown>, R = unknown>(value: T, iteratee?: Iteratee<unknown, R>): Record<string, R>
+export function defaults<T extends Record<string, unknown>>(target: T, ...sources: Array<Record<string, unknown>>): T
+export function assignDefined<T extends Record<string, unknown>>(target: T, ...sources: Array<Record<string, unknown>>): T
+export function cloneShallow<T = unknown>(value: T): T
+export function cloneDeep<T = unknown>(value: T): T
+export function mergeDeep<T extends Record<string, unknown>>(target: T, ...sources: Array<Record<string, unknown>>): T
+
+export function isEqual(left: unknown, right: unknown): boolean

package/index.js

@@ -0,0 +1,30 @@
+"use strict"
+
+const bridge = require("./lib/bridge.js")
+const array = require("./lib/array.js")
+const object = require("./lib/object.js")
+const compare = require("./lib/compare.js")
+
+module.exports = bridge.attachQezorBridge({
+  ...array,
+  ...object,
+  ...compare,
+  QEZOR_BRIDGE: bridge.QEZOR_BRIDGE,
+  createQezorBridge: bridge.createQezorBridge,
+  attachQezorBridge: bridge.attachQezorBridge,
+  readQezorBridge: bridge.readQezorBridge,
+  hasQezorCapability: bridge.hasQezorCapability,
+}, {
+  name: "@qezor/structkit",
+  kind: "library",
+  version: "1.0.0",
+  capabilities: [
+    "bridge",
+    "structure",
+    "structure:array",
+    "structure:object",
+    "structure:path",
+    "structure:compare",
+  ],
+  adapters: ["plain-data"],
+})

package/index.mjs

@@ -0,0 +1,39 @@
+import mod from "./index.js"
+
+export const {
+  toArray,
+  chunk,
+  compact,
+  uniq,
+  uniqBy,
+  difference,
+  intersection,
+  partition,
+  groupBy,
+  countBy,
+  keyBy,
+  sortBy,
+  flatMap,
+  sumBy,
+  tokenizePath,
+  get,
+  has,
+  set,
+  unset,
+  pick,
+  omit,
+  mapValues,
+  defaults,
+  assignDefined,
+  cloneShallow,
+  cloneDeep,
+  mergeDeep,
+  isEqual,
+  QEZOR_BRIDGE,
+  createQezorBridge,
+  attachQezorBridge,
+  readQezorBridge,
+  hasQezorCapability,
+} = mod
+
+export default mod

package/lib/array.js

@@ -0,0 +1,188 @@
+"use strict"
+
+const { createIteratee } = require("./shared.js")
+
+function toArray(value) {
+  if (value == null) return []
+  if (Array.isArray(value)) return value.slice()
+  if (typeof value === "string") return Array.from(value)
+  if (typeof value[Symbol.iterator] === "function") return Array.from(value)
+  if (typeof value === "object") return Object.values(value)
+  return [value]
+}
+
+function chunk(value, size = 1) {
+  const list = toArray(value)
+  const width = Math.max(1, Number.parseInt(String(size), 10) || 1)
+  const output = []
+  for (let index = 0; index < list.length; index += width) {
+    output.push(list.slice(index, index + width))
+  }
+  return output
+}
+
+function compact(value) {
+  return toArray(value).filter(Boolean)
+}
+
+function uniq(value) {
+  return [...new Set(toArray(value))]
+}
+
+function uniqBy(value, iteratee) {
+  const list = toArray(value)
+  const resolve = createIteratee(iteratee)
+  const seen = new Set()
+  const output = []
+
+  for (let index = 0; index < list.length; index += 1) {
+    const item = list[index]
+    const marker = resolve(item, index, list)
+    if (seen.has(marker)) continue
+    seen.add(marker)
+    output.push(item)
+  }
+
+  return output
+}
+
+function difference(value, values) {
+  const blocked = new Set(toArray(values))
+  return toArray(value).filter((item) => !blocked.has(item))
+}
+
+function intersection(value, values) {
+  const allowed = new Set(toArray(values))
+  return toArray(value).filter((item) => allowed.has(item))
+}
+
+function partition(value, iteratee) {
+  const list = toArray(value)
+  const resolve = createIteratee(iteratee)
+  const truthy = []
+  const falsy = []
+
+  for (let index = 0; index < list.length; index += 1) {
+    const item = list[index]
+    if (resolve(item, index, list)) {
+      truthy.push(item)
+    } else {
+      falsy.push(item)
+    }
+  }
+
+  return [truthy, falsy]
+}
+
+function groupBy(value, iteratee) {
+  const list = toArray(value)
+  const resolve = createIteratee(iteratee)
+  const output = {}
+
+  for (let index = 0; index < list.length; index += 1) {
+    const item = list[index]
+    const key = String(resolve(item, index, list))
+    if (!Object.prototype.hasOwnProperty.call(output, key)) output[key] = []
+    output[key].push(item)
+  }
+
+  return output
+}
+
+function countBy(value, iteratee) {
+  const list = toArray(value)
+  const resolve = createIteratee(iteratee)
+  const output = {}
+
+  for (let index = 0; index < list.length; index += 1) {
+    const item = list[index]
+    const key = String(resolve(item, index, list))
+    output[key] = (output[key] || 0) + 1
+  }
+
+  return output
+}
+
+function keyBy(value, iteratee) {
+  const list = toArray(value)
+  const resolve = createIteratee(iteratee)
+  const output = {}
+
+  for (let index = 0; index < list.length; index += 1) {
+    const item = list[index]
+    output[String(resolve(item, index, list))] = item
+  }
+
+  return output
+}
+
+function sortBy(value, iteratee) {
+  const list = toArray(value)
+  const resolve = createIteratee(iteratee)
+  const ranked = []
+
+  for (let index = 0; index < list.length; index += 1) {
+    ranked.push({
+      item: list[index],
+      index,
+      rank: resolve(list[index], index, list),
+    })
+  }
+
+  ranked.sort((left, right) => {
+    if (left.rank < right.rank) return -1
+    if (left.rank > right.rank) return 1
+    return left.index - right.index
+  })
+
+  return ranked.map((entry) => entry.item)
+}
+
+function flatMap(value, iteratee) {
+  const list = toArray(value)
+  const resolve = createIteratee(iteratee)
+  const output = []
+
+  for (let index = 0; index < list.length; index += 1) {
+    const result = resolve(list[index], index, list)
+    if (Array.isArray(result)) {
+      for (let inner = 0; inner < result.length; inner += 1) {
+        output.push(result[inner])
+      }
+    } else {
+      output.push(result)
+    }
+  }
+
+  return output
+}
+
+function sumBy(value, iteratee) {
+  const list = toArray(value)
+  const resolve = createIteratee(iteratee)
+  let total = 0
+
+  for (let index = 0; index < list.length; index += 1) {
+    const number = Number(resolve(list[index], index, list))
+    if (Number.isFinite(number)) total += number
+  }
+
+  return total
+}
+
+module.exports = {
+  toArray,
+  chunk,
+  compact,
+  uniq,
+  uniqBy,
+  difference,
+  intersection,
+  partition,
+  groupBy,
+  countBy,
+  keyBy,
+  sortBy,
+  flatMap,
+  sumBy,
+}

package/lib/bridge.js

@@ -0,0 +1,49 @@
+"use strict"
+
+const QEZOR_BRIDGE = Symbol.for("qezor.bridge")
+
+function normalizeList(values) {
+  if (!Array.isArray(values)) return []
+  return [...new Set(values.map((value) => String(value).trim()).filter(Boolean))].sort()
+}
+
+function createQezorBridge(input = {}) {
+  return {
+    name: input.name || "unknown",
+    kind: input.kind || "library",
+    version: input.version || "0.0.0",
+    capabilities: normalizeList(input.capabilities),
+    adapters: normalizeList(input.adapters),
+    dependencies: normalizeList(input.dependencies),
+  }
+}
+
+function attachQezorBridge(target, input = {}) {
+  const bridge = createQezorBridge(input)
+  Object.defineProperty(target, QEZOR_BRIDGE, {
+    enumerable: false,
+    configurable: true,
+    writable: false,
+    value: bridge,
+  })
+  return target
+}
+
+function readQezorBridge(target) {
+  if (!target || (typeof target !== "object" && typeof target !== "function")) return null
+  return target[QEZOR_BRIDGE] || null
+}
+
+function hasQezorCapability(target, capability) {
+  const bridge = readQezorBridge(target)
+  if (!bridge) return false
+  return bridge.capabilities.includes(String(capability))
+}
+
+module.exports = {
+  QEZOR_BRIDGE,
+  createQezorBridge,
+  attachQezorBridge,
+  readQezorBridge,
+  hasQezorCapability,
+}

package/lib/compare.js

@@ -0,0 +1,94 @@
+"use strict"
+
+const { isObjectLike, isTypedArray } = require("./shared.js")
+
+function isEqual(left, right) {
+  if (Object.is(left, right)) return true
+
+  const stack = [{ left, right }]
+  const seen = new WeakMap()
+
+  while (stack.length) {
+    const frame = stack.pop()
+    const a = frame.left
+    const b = frame.right
+
+    if (Object.is(a, b)) continue
+
+    const aIsObject = isObjectLike(a)
+    const bIsObject = isObjectLike(b)
+
+    if (!aIsObject || !bIsObject) return false
+
+    const leftTag = Object.prototype.toString.call(a)
+    const rightTag = Object.prototype.toString.call(b)
+    if (leftTag !== rightTag) return false
+
+    let seenRights = seen.get(a)
+    if (seenRights && seenRights.has(b)) continue
+    if (!seenRights) {
+      seenRights = new WeakSet()
+      seen.set(a, seenRights)
+    }
+    seenRights.add(b)
+
+    if (Array.isArray(a)) {
+      if (!Array.isArray(b) || a.length !== b.length) return false
+      for (let index = 0; index < a.length; index += 1) {
+        stack.push({ left: a[index], right: b[index] })
+      }
+      continue
+    }
+
+    if (a instanceof Date) {
+      if (a.getTime() !== b.getTime()) return false
+      continue
+    }
+
+    if (a instanceof RegExp) {
+      if (a.source !== b.source || a.flags !== b.flags) return false
+      continue
+    }
+
+    if (isTypedArray(a)) {
+      if (!isTypedArray(b) || a.length !== b.length) return false
+      for (let index = 0; index < a.length; index += 1) {
+        if (a[index] !== b[index]) return false
+      }
+      continue
+    }
+
+    if (a instanceof Map) {
+      if (!(b instanceof Map) || a.size !== b.size) return false
+      for (const [key, value] of a.entries()) {
+        if (!b.has(key)) return false
+        stack.push({ left: value, right: b.get(key) })
+      }
+      continue
+    }
+
+    if (a instanceof Set) {
+      if (!(b instanceof Set) || a.size !== b.size) return false
+      for (const value of a.values()) {
+        if (!b.has(value)) return false
+      }
+      continue
+    }
+
+    const keysA = Object.keys(a)
+    const keysB = Object.keys(b)
+    if (keysA.length !== keysB.length) return false
+
+    for (let index = 0; index < keysA.length; index += 1) {
+      const key = keysA[index]
+      if (!Object.prototype.hasOwnProperty.call(b, key)) return false
+      stack.push({ left: a[key], right: b[key] })
+    }
+  }
+
+  return true
+}
+
+module.exports = {
+  isEqual,
+}

package/lib/object.js

@@ -0,0 +1,202 @@
+"use strict"
+
+const {
+  isObjectLike,
+  isPlainObject,
+  tokenizePath,
+  getValueByPath,
+  createIteratee,
+  cloneShallow,
+  cloneDeep,
+} = require("./shared.js")
+
+function get(value, path, defaultValue) {
+  const resolved = getValueByPath(value, path)
+  return resolved === undefined ? defaultValue : resolved
+}
+
+function has(value, path) {
+  const tokens = tokenizePath(path)
+  if (!tokens.length) return false
+
+  let current = value
+  for (let index = 0; index < tokens.length; index += 1) {
+    if (!isObjectLike(current) && !Array.isArray(current)) return false
+    if (!Object.prototype.hasOwnProperty.call(current, tokens[index])) return false
+    current = current[tokens[index]]
+  }
+
+  return true
+}
+
+function set(target, path, nextValue) {
+  if (!isObjectLike(target) && !Array.isArray(target)) return target
+
+  const tokens = tokenizePath(path)
+  if (!tokens.length) return target
+
+  let current = target
+  for (let index = 0; index < tokens.length - 1; index += 1) {
+    const token = tokens[index]
+    const nextToken = tokens[index + 1]
+    const existing = current[token]
+
+    if (!isObjectLike(existing) && !Array.isArray(existing)) {
+      current[token] = typeof nextToken === "number" ? [] : {}
+    }
+
+    current = current[token]
+  }
+
+  current[tokens[tokens.length - 1]] = nextValue
+  return target
+}
+
+function unset(target, path) {
+  if (!isObjectLike(target) && !Array.isArray(target)) return false
+
+  const tokens = tokenizePath(path)
+  if (!tokens.length) return false
+
+  let current = target
+  for (let index = 0; index < tokens.length - 1; index += 1) {
+    if (!isObjectLike(current) && !Array.isArray(current)) return false
+    if (!Object.prototype.hasOwnProperty.call(current, tokens[index])) return false
+    current = current[tokens[index]]
+  }
+
+  const last = tokens[tokens.length - 1]
+  if (!isObjectLike(current) && !Array.isArray(current)) return false
+  if (!Object.prototype.hasOwnProperty.call(current, last)) return false
+
+  if (Array.isArray(current) && typeof last === "number") {
+    current.splice(last, 1)
+  } else {
+    delete current[last]
+  }
+
+  return true
+}
+
+function pick(value, paths) {
+  const selectedPaths = Array.isArray(paths) ? paths : [paths]
+  const output = {}
+
+  for (const path of selectedPaths) {
+    if (!has(value, path)) continue
+    set(output, path, get(value, path))
+  }
+
+  return output
+}
+
+function omit(value, paths) {
+  const output = cloneDeep(value)
+  const omittedPaths = Array.isArray(paths) ? paths : [paths]
+
+  for (const path of omittedPaths) {
+    unset(output, path)
+  }
+
+  return output
+}
+
+function mapValues(value, iteratee) {
+  if (!isPlainObject(value)) return {}
+  const resolve = createIteratee(iteratee)
+  const output = {}
+  const keys = Object.keys(value)
+
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index]
+    output[key] = resolve(value[key], key, value)
+  }
+
+  return output
+}
+
+function defaults(target, ...sources) {
+  const output = isPlainObject(target) ? target : {}
+
+  for (const source of sources) {
+    if (!isPlainObject(source)) continue
+    for (const key of Object.keys(source)) {
+      if (output[key] === undefined) output[key] = source[key]
+    }
+  }
+
+  return output
+}
+
+function assignDefined(target, ...sources) {
+  const output = isObjectLike(target) || Array.isArray(target) ? target : {}
+
+  for (const source of sources) {
+    if (!isObjectLike(source) && !Array.isArray(source)) continue
+    for (const [key, value] of Object.entries(source)) {
+      if (value !== undefined) output[key] = value
+    }
+  }
+
+  return output
+}
+
+function mergeDeep(target, ...sources) {
+  const output = isPlainObject(target) ? target : {}
+
+  for (const source of sources) {
+    if (!isPlainObject(source)) continue
+
+    const stack = [{ destination: output, source }]
+    while (stack.length) {
+      const frame = stack.pop()
+      const { destination, source: currentSource } = frame
+      const keys = Object.keys(currentSource)
+
+      for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index]
+        const nextValue = currentSource[key]
+        const currentValue = destination[key]
+
+        if (isPlainObject(nextValue)) {
+          if (!isPlainObject(currentValue)) destination[key] = {}
+          stack.push({
+            destination: destination[key],
+            source: nextValue,
+          })
+          continue
+        }
+
+        if (Array.isArray(nextValue)) {
+          destination[key] = cloneDeep(nextValue)
+          continue
+        }
+
+        if (isObjectLike(nextValue)) {
+          destination[key] = cloneDeep(nextValue)
+          continue
+        }
+
+        destination[key] = nextValue
+      }
+    }
+  }
+
+  return output
+}
+
+module.exports = {
+  tokenizePath,
+  get,
+  has,
+  set,
+  unset,
+  pick,
+  omit,
+  mapValues,
+  defaults,
+  assignDefined,
+  cloneShallow,
+  cloneDeep,
+  mergeDeep,
+}

package/lib/shared.js

@@ -0,0 +1,249 @@
+"use strict"
+
+function isObjectLike(value) {
+  return value !== null && typeof value === "object"
+}
+
+function isPlainObject(value) {
+  if (!isObjectLike(value)) return false
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}
+
+function isTypedArray(value) {
+  return ArrayBuffer.isView(value) && !(value instanceof DataView)
+}
+
+function normalizePathToken(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return value
+  const text = String(value).trim()
+  if (!text) return ""
+  if (/^(0|[1-9]\d*)$/.test(text)) return Number(text)
+  return text
+}
+
+function tokenizePath(path) {
+  if (Array.isArray(path)) {
+    const tokens = []
+    for (const token of path) {
+      const normalized = normalizePathToken(token)
+      if (normalized === "") continue
+      tokens.push(normalized)
+    }
+    return tokens
+  }
+
+  if (typeof path === "number") return [normalizePathToken(path)]
+  if (path == null) return []
+
+  const text = String(path)
+  if (!text.trim()) return []
+
+  const tokens = []
+  let buffer = ""
+  let bracket = ""
+  let inBracket = false
+  let quote = ""
+
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index]
+
+    if (!inBracket) {
+      if (character === ".") {
+        if (buffer) {
+          tokens.push(normalizePathToken(buffer))
+          buffer = ""
+        }
+        continue
+      }
+
+      if (character === "[") {
+        if (buffer) {
+          tokens.push(normalizePathToken(buffer))
+          buffer = ""
+        }
+        inBracket = true
+        bracket = ""
+        quote = ""
+        continue
+      }
+
+      buffer += character
+      continue
+    }
+
+    if (quote) {
+      if (character === quote) {
+        quote = ""
+      } else {
+        bracket += character
+      }
+      continue
+    }
+
+    if (character === "'" || character === "\"") {
+      quote = character
+      continue
+    }
+
+    if (character === "]") {
+      const normalized = normalizePathToken(bracket)
+      if (normalized !== "") tokens.push(normalized)
+      inBracket = false
+      bracket = ""
+      continue
+    }
+
+    bracket += character
+  }
+
+  if (buffer) tokens.push(normalizePathToken(buffer))
+  return tokens
+}
+
+function getValueByPath(value, path) {
+  const tokens = tokenizePath(path)
+  let current = value
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    if (current == null) return undefined
+    current = current[tokens[index]]
+  }
+
+  return current
+}
+
+function createIteratee(iteratee) {
+  if (typeof iteratee === "function") return iteratee
+  if (iteratee == null) return (value) => value
+  return (value) => getValueByPath(value, iteratee)
+}
+
+function cloneShallow(value) {
+  if (Array.isArray(value)) return value.slice()
+  if (isPlainObject(value)) return { ...value }
+  if (value instanceof Date) return new Date(value.getTime())
+  if (value instanceof RegExp) return new RegExp(value.source, value.flags)
+  if (value instanceof Map) return new Map(value)
+  if (value instanceof Set) return new Set(value)
+  if (isTypedArray(value)) return value.slice()
+  return value
+}
+
+function initClone(value) {
+  if (Array.isArray(value)) return []
+  if (isPlainObject(value)) return {}
+  if (value instanceof Date) return new Date(value.getTime())
+  if (value instanceof RegExp) return new RegExp(value.source, value.flags)
+  if (value instanceof Map) return new Map()
+  if (value instanceof Set) return new Set()
+  if (isTypedArray(value)) return value.slice()
+  return value
+}
+
+function cloneDeep(value) {
+  if (!isObjectLike(value)) return value
+
+  const root = initClone(value)
+  if (!isObjectLike(root)) return root
+
+  const seen = new Map([[value, root]])
+  const stack = [{ source: value, target: root }]
+
+  while (stack.length) {
+    const frame = stack.pop()
+    const { source, target } = frame
+
+    if (Array.isArray(source)) {
+      for (let index = 0; index < source.length; index += 1) {
+        const item = source[index]
+        if (!isObjectLike(item)) {
+          target[index] = item
+          continue
+        }
+        if (seen.has(item)) {
+          target[index] = seen.get(item)
+          continue
+        }
+        const child = initClone(item)
+        target[index] = child
+        if (isObjectLike(child)) {
+          seen.set(item, child)
+          stack.push({ source: item, target: child })
+        }
+      }
+      continue
+    }
+
+    if (source instanceof Map) {
+      for (const [key, item] of source.entries()) {
+        if (!isObjectLike(item)) {
+          target.set(key, item)
+          continue
+        }
+        if (seen.has(item)) {
+          target.set(key, seen.get(item))
+          continue
+        }
+        const child = initClone(item)
+        target.set(key, child)
+        if (isObjectLike(child)) {
+          seen.set(item, child)
+          stack.push({ source: item, target: child })
+        }
+      }
+      continue
+    }
+
+    if (source instanceof Set) {
+      for (const item of source.values()) {
+        if (!isObjectLike(item)) {
+          target.add(item)
+          continue
+        }
+        if (seen.has(item)) {
+          target.add(seen.get(item))
+          continue
+        }
+        const child = initClone(item)
+        target.add(child)
+        if (isObjectLike(child)) {
+          seen.set(item, child)
+          stack.push({ source: item, target: child })
+        }
+      }
+      continue
+    }
+
+    for (const key of Object.keys(source)) {
+      const item = source[key]
+      if (!isObjectLike(item)) {
+        target[key] = item
+        continue
+      }
+      if (seen.has(item)) {
+        target[key] = seen.get(item)
+        continue
+      }
+      const child = initClone(item)
+      target[key] = child
+      if (isObjectLike(child)) {
+        seen.set(item, child)
+        stack.push({ source: item, target: child })
+      }
+    }
+  }
+
+  return root
+}
+
+module.exports = {
+  isObjectLike,
+  isPlainObject,
+  isTypedArray,
+  tokenizePath,
+  getValueByPath,
+  createIteratee,
+  cloneShallow,
+  cloneDeep,
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@qezor/structkit",
+  "version": "1.0.0",
+  "description": "Iterative array and object utilities for high-use data shaping without callback hell or recursion-heavy internals.",
+  "files": [
+    "LICENSE",
+    "README.md",
+    "index.js",
+    "index.mjs",
+    "index.d.ts",
+    "bridge.js",
+    "bridge.mjs",
+    "bridge.d.ts",
+    "lib",
+    "test.js"
+  ],
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.js",
+      "import": "./index.mjs",
+      "default": "./index.js"
+    },
+    "./bridge": {
+      "types": "./bridge.d.ts",
+      "require": "./bridge.js",
+      "import": "./bridge.mjs",
+      "default": "./bridge.js"
+    }
+  },
+  "scripts": {
+    "test": "node --test test.js",
+    "check": "node --test test.js",
+    "pack:dry": "npm pack --dry-run",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "array",
+    "object",
+    "utility",
+    "lodash",
+    "iterative",
+    "performance"
+  ],
+  "author": "Abdul Ahad",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "type": "commonjs",
+  "sideEffects": false
+}

package/test.js

@@ -0,0 +1,90 @@
+"use strict"
+
+const test = require("node:test")
+const assert = require("node:assert/strict")
+const structkit = require("./index.js")
+
+test("array helpers cover grouping uniqueness and sums", () => {
+  const buyers = [
+    { id: "u1", role: "buyer", qty: 2 },
+    { id: "u2", role: "buyer", qty: 5 },
+    { id: "u3", role: "seller", qty: 1 },
+    { id: "u3", role: "seller", qty: 1 },
+  ]
+
+  assert.deepEqual(structkit.chunk([1, 2, 3, 4, 5], 2), [[1, 2], [3, 4], [5]])
+  assert.deepEqual(structkit.compact([0, 1, false, 2, "", 3]), [1, 2, 3])
+  assert.deepEqual(structkit.uniq([1, 1, 2, 3, 3]), [1, 2, 3])
+  assert.deepEqual(structkit.uniqBy(buyers, "id").map((item) => item.id), ["u1", "u2", "u3"])
+  assert.deepEqual(structkit.groupBy(buyers, "role"), {
+    buyer: [buyers[0], buyers[1]],
+    seller: [buyers[2], buyers[3]],
+  })
+  assert.deepEqual(structkit.countBy(buyers, "role"), {
+    buyer: 2,
+    seller: 2,
+  })
+  assert.equal(structkit.sumBy(buyers, "qty"), 9)
+})
+
+test("path and object helpers work iteratively", () => {
+  const state = {}
+
+  structkit.set(state, "queue.regions[0].city", "Pune")
+  structkit.set(state, "queue.regions[0].active", true)
+  structkit.set(state, ["queue", "meta", "moq"], 500)
+
+  assert.equal(structkit.get(state, "queue.regions[0].city"), "Pune")
+  assert.equal(structkit.has(state, "queue.meta.moq"), true)
+  assert.deepEqual(structkit.tokenizePath("queue.regions[0].city"), ["queue", "regions", 0, "city"])
+  assert.deepEqual(structkit.pick(state, ["queue.meta.moq", "queue.regions[0].city"]), {
+    queue: {
+      meta: { moq: 500 },
+      regions: [{ city: "Pune" }],
+    },
+  })
+
+  const omitted = structkit.omit(state, "queue.regions[0].active")
+  assert.equal(structkit.has(omitted, "queue.regions[0].active"), false)
+  assert.equal(structkit.has(state, "queue.regions[0].active"), true)
+})
+
+test("cloneDeep and mergeDeep avoid shallow aliasing", () => {
+  const input = {
+    demand: {
+      buyers: [{ id: "u1" }],
+      counts: { joined: 2 },
+    },
+  }
+
+  const cloned = structkit.cloneDeep(input)
+  cloned.demand.buyers[0].id = "u2"
+
+  assert.equal(input.demand.buyers[0].id, "u1")
+
+  const merged = structkit.mergeDeep({}, { demand: { joined: 2, nested: { a: 1 } } }, { demand: { buyers: 3, nested: { b: 2 } } })
+  assert.deepEqual(merged, {
+    demand: {
+      joined: 2,
+      buyers: 3,
+      nested: { a: 1, b: 2 },
+    },
+  })
+})
+
+test("isEqual handles deep and cyclic values without recursion", () => {
+  const left = { demand: { buyers: [1, 2, 3] } }
+  const right = { demand: { buyers: [1, 2, 3] } }
+
+  left.self = left
+  right.self = right
+
+  assert.equal(structkit.isEqual(left, right), true)
+  assert.equal(structkit.isEqual(left, { demand: { buyers: [1, 2] } }), false)
+})
+
+test("bridge metadata is attached", () => {
+  const bridge = structkit.readQezorBridge(structkit)
+  assert.equal(bridge.name, "@qezor/structkit")
+  assert.equal(structkit.hasQezorCapability(structkit, "structure:path"), true)
+})