@stryke/helpers 0.9.34 → 0.9.36

package/dist/semaphore.mjs

@@ -1,2 +1,105 @@
-var e=class{capacity;available;deferredTasks=[];constructor(e){this.capacity=e,this.available=e}async acquire(){if(this.available>0){this.available--;return}return new Promise(e=>{this.deferredTasks.push(e)})}release(){let e=this.deferredTasks.shift();if(e!=null){e();return}this.available<this.capacity&&this.available++}};export{e as Semaphore};
+//#region src/semaphore.ts
+/**
+* A counting semaphore for async functions that manages available permits.
+* Semaphores are mainly used to limit the number of concurrent async tasks.
+*
+* Each `acquire` operation takes a permit or waits until one is available.
+* Each `release` operation adds a permit, potentially allowing a waiting task to proceed.
+*
+* The semaphore ensures fairness by maintaining a FIFO (First In, First Out) order for acquirers.
+*
+* @example
+* const sema = new Semaphore(2);
+*
+* async function task() {
+*   await sema.acquire();
+*   try {
+*     // This code can only be executed by two tasks at the same time
+*   } finally {
+*     sema.release();
+*   }
+* }
+*
+* task();
+* task();
+* task(); // This task will wait until one of the previous tasks releases the semaphore.
+*/
+var Semaphore = class {
+	/**
+	* The maximum number of concurrent operations allowed.
+	*/
+	capacity;
+	/**
+	* The number of available permits.
+	*/
+	available;
+	deferredTasks = [];
+	/**
+	* Creates an instance of Semaphore.
+	* @param capacity - The maximum number of concurrent operations allowed.
+	*
+	* @example
+	* ```ts
+	* const sema = new Semaphore(3); // Allows up to 3 concurrent operations.
+	* ```
+	*/
+	constructor(capacity) {
+		this.capacity = capacity;
+		this.available = capacity;
+	}
+	/**
+	* Acquires a semaphore, blocking if necessary until one is available.
+	*
+	* @example
+	* ```ts
+	* const sema = new Semaphore(1);
+	*
+	* async function criticalSection() {
+	*   await sema.acquire();
+	*   try {
+	*     // This code section cannot be executed simultaneously
+	*   } finally {
+	*     sema.release();
+	*   }
+	* }
+	* ```
+	*
+	* @returns A promise that resolves when the semaphore is acquired.
+	*/
+	async acquire() {
+		if (this.available > 0) {
+			this.available--;
+			return;
+		}
+		return new Promise((resolve) => {
+			this.deferredTasks.push(resolve);
+		});
+	}
+	/**
+	* Releases a semaphore, allowing one more operation to proceed.
+	*
+	* @example
+	* const sema = new Semaphore(1);
+	*
+	* async function task() {
+	*   await sema.acquire();
+	*   try {
+	*     // This code can only be executed by two tasks at the same time
+	*   } finally {
+	*     sema.release(); // Allows another waiting task to proceed.
+	*   }
+	* }
+	*/
+	release() {
+		const deferredTask = this.deferredTasks.shift();
+		if (deferredTask != null) {
+			deferredTask();
+			return;
+		}
+		if (this.available < this.capacity) this.available++;
+	}
+};
+
+//#endregion
+export { Semaphore };
 //# sourceMappingURL=semaphore.mjs.map

package/dist/semaphore.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"semaphore.mjs","names":[],"sources":["../src/semaphore.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\n/**\n * A counting semaphore for async functions that manages available permits.\n * Semaphores are mainly used to limit the number of concurrent async tasks.\n *\n * Each `acquire` operation takes a permit or waits until one is available.\n * Each `release` operation adds a permit, potentially allowing a waiting task to proceed.\n *\n * The semaphore ensures fairness by maintaining a FIFO (First In, First Out) order for acquirers.\n *\n * @example\n * const sema = new Semaphore(2);\n *\n * async function task() {\n *   await sema.acquire();\n *   try {\n *     // This code can only be executed by two tasks at the same time\n *   } finally {\n *     sema.release();\n *   }\n * }\n *\n * task();\n * task();\n * task(); // This task will wait until one of the previous tasks releases the semaphore.\n */\nexport class Semaphore {\n  /**\n   * The maximum number of concurrent operations allowed.\n   */\n  public capacity: number;\n\n  /**\n   * The number of available permits.\n   */\n  public available: number;\n\n  private deferredTasks: Array<() => void> = [];\n\n  /**\n   * Creates an instance of Semaphore.\n   * @param capacity - The maximum number of concurrent operations allowed.\n   *\n   * @example\n   * ```ts\n   * const sema = new Semaphore(3); // Allows up to 3 concurrent operations.\n   * ```\n   */\n  constructor(capacity: number) {\n    this.capacity = capacity;\n    this.available = capacity;\n  }\n\n  /**\n   * Acquires a semaphore, blocking if necessary until one is available.\n   *\n   * @example\n   * ```ts\n   * const sema = new Semaphore(1);\n   *\n   * async function criticalSection() {\n   *   await sema.acquire();\n   *   try {\n   *     // This code section cannot be executed simultaneously\n   *   } finally {\n   *     sema.release();\n   *   }\n   * }\n   * ```\n   *\n   * @returns A promise that resolves when the semaphore is acquired.\n   */\n  async acquire(): Promise<void> {\n    if (this.available > 0) {\n      this.available--;\n      return;\n    }\n\n    return new Promise<void>(resolve => {\n      this.deferredTasks.push(resolve);\n    });\n  }\n\n  /**\n   * Releases a semaphore, allowing one more operation to proceed.\n   *\n   * @example\n   * const sema = new Semaphore(1);\n   *\n   * async function task() {\n   *   await sema.acquire();\n   *   try {\n   *     // This code can only be executed by two tasks at the same time\n   *   } finally {\n   *     sema.release(); // Allows another waiting task to proceed.\n   *   }\n   * }\n   */\n  release(): void {\n    const deferredTask = this.deferredTasks.shift();\n\n    if (deferredTask != null) {\n      deferredTask();\n      return;\n    }\n\n    if (this.available < this.capacity) {\n      this.available++;\n    }\n  }\n}\n"],"mappings":"AA0CA,IAAa,EAAb,KAAuB,CAIrB,SAKA,UAEA,cAA2C,EAAE,CAW7C,YAAY,EAAkB,CAC5B,KAAK,SAAW,EAChB,KAAK,UAAY,EAsBnB,MAAM,SAAyB,CAC7B,GAAI,KAAK,UAAY,EAAG,CACtB,KAAK,YACL,OAGF,OAAO,IAAI,QAAc,GAAW,CAClC,KAAK,cAAc,KAAK,EAAQ,EAChC,CAkBJ,SAAgB,CACd,IAAM,EAAe,KAAK,cAAc,OAAO,CAE/C,GAAI,GAAgB,KAAM,CACxB,GAAc,CACd,OAGE,KAAK,UAAY,KAAK,UACxB,KAAK"}
+{"version":3,"file":"semaphore.mjs","names":[],"sources":["../src/semaphore.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\n/**\n * A counting semaphore for async functions that manages available permits.\n * Semaphores are mainly used to limit the number of concurrent async tasks.\n *\n * Each `acquire` operation takes a permit or waits until one is available.\n * Each `release` operation adds a permit, potentially allowing a waiting task to proceed.\n *\n * The semaphore ensures fairness by maintaining a FIFO (First In, First Out) order for acquirers.\n *\n * @example\n * const sema = new Semaphore(2);\n *\n * async function task() {\n *   await sema.acquire();\n *   try {\n *     // This code can only be executed by two tasks at the same time\n *   } finally {\n *     sema.release();\n *   }\n * }\n *\n * task();\n * task();\n * task(); // This task will wait until one of the previous tasks releases the semaphore.\n */\nexport class Semaphore {\n  /**\n   * The maximum number of concurrent operations allowed.\n   */\n  public capacity: number;\n\n  /**\n   * The number of available permits.\n   */\n  public available: number;\n\n  private deferredTasks: Array<() => void> = [];\n\n  /**\n   * Creates an instance of Semaphore.\n   * @param capacity - The maximum number of concurrent operations allowed.\n   *\n   * @example\n   * ```ts\n   * const sema = new Semaphore(3); // Allows up to 3 concurrent operations.\n   * ```\n   */\n  constructor(capacity: number) {\n    this.capacity = capacity;\n    this.available = capacity;\n  }\n\n  /**\n   * Acquires a semaphore, blocking if necessary until one is available.\n   *\n   * @example\n   * ```ts\n   * const sema = new Semaphore(1);\n   *\n   * async function criticalSection() {\n   *   await sema.acquire();\n   *   try {\n   *     // This code section cannot be executed simultaneously\n   *   } finally {\n   *     sema.release();\n   *   }\n   * }\n   * ```\n   *\n   * @returns A promise that resolves when the semaphore is acquired.\n   */\n  async acquire(): Promise<void> {\n    if (this.available > 0) {\n      this.available--;\n      return;\n    }\n\n    return new Promise<void>(resolve => {\n      this.deferredTasks.push(resolve);\n    });\n  }\n\n  /**\n   * Releases a semaphore, allowing one more operation to proceed.\n   *\n   * @example\n   * const sema = new Semaphore(1);\n   *\n   * async function task() {\n   *   await sema.acquire();\n   *   try {\n   *     // This code can only be executed by two tasks at the same time\n   *   } finally {\n   *     sema.release(); // Allows another waiting task to proceed.\n   *   }\n   * }\n   */\n  release(): void {\n    const deferredTask = this.deferredTasks.shift();\n\n    if (deferredTask != null) {\n      deferredTask();\n      return;\n    }\n\n    if (this.available < this.capacity) {\n      this.available++;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,YAAb,MAAuB;;;;CAIrB,AAAO;;;;CAKP,AAAO;CAEP,AAAQ,gBAAmC,EAAE;;;;;;;;;;CAW7C,YAAY,UAAkB;AAC5B,OAAK,WAAW;AAChB,OAAK,YAAY;;;;;;;;;;;;;;;;;;;;;CAsBnB,MAAM,UAAyB;AAC7B,MAAI,KAAK,YAAY,GAAG;AACtB,QAAK;AACL;;AAGF,SAAO,IAAI,SAAc,YAAW;AAClC,QAAK,cAAc,KAAK,QAAQ;IAChC;;;;;;;;;;;;;;;;;CAkBJ,UAAgB;EACd,MAAM,eAAe,KAAK,cAAc,OAAO;AAE/C,MAAI,gBAAgB,MAAM;AACxB,iBAAc;AACd;;AAGF,MAAI,KAAK,YAAY,KAAK,SACxB,MAAK"}

package/dist/set-field.cjs

@@ -1 +1,30 @@
-const e=require(`./to-path.cjs`),t=require(`./type-checks/src/is-string.cjs`),n=require(`./type-checks/src/is-object-index.cjs`);function r(r,i,a){let o=Array.isArray(i)?i:t.isString(i)?e.toPath(i):[i];for(let e of o)if(e===`__proto__`||e===`constructor`||e===`prototype`)throw Error(`Invalid key in path: ${e}`);let s=r;for(let e=0;e<o.length-1;e++){let t=o[e],r=o[e+1];s[t]===null&&(s[t]=n.isObjectIndex(r)?[]:{}),s=s[t]}let c=o.at(-1);return c&&(s[c]=a),r}exports.setField=r;
+const require_to_path = require('./to-path.cjs');
+const require_is_string = require('./type-checks/src/is-string.cjs');
+const require_is_object_index = require('./type-checks/src/is-object-index.cjs');
+
+//#region src/set-field.ts
+/**
+* Sets a value at a given deep path in an object.
+*
+* @param object - The object to set the value in.
+* @param path - The deep path to set the value at.
+* @param value - The value to set.
+* @returns The object with the value set at the given deep path.
+*/
+function setField(object, path, value) {
+	const resolvedPath = Array.isArray(path) ? path : require_is_string.isString(path) ? require_to_path.toPath(path) : [path];
+	for (const key of resolvedPath) if (key === "__proto__" || key === "constructor" || key === "prototype") throw new Error(`Invalid key in path: ${key}`);
+	let current = object;
+	for (let i = 0; i < resolvedPath.length - 1; i++) {
+		const key = resolvedPath[i];
+		const nextKey = resolvedPath[i + 1];
+		if (current[key] === null) current[key] = require_is_object_index.isObjectIndex(nextKey) ? [] : {};
+		current = current[key];
+	}
+	const lastKey = resolvedPath.at(-1);
+	if (lastKey) current[lastKey] = value;
+	return object;
+}
+
+//#endregion
+exports.setField = setField;

package/dist/set-field.mjs

@@ -1,2 +1,31 @@
-import{toPath as e}from"./to-path.mjs";import{isString as t}from"./type-checks/src/is-string.mjs";import{isObjectIndex as n}from"./type-checks/src/is-object-index.mjs";function r(r,i,a){let o=Array.isArray(i)?i:t(i)?e(i):[i];for(let e of o)if(e===`__proto__`||e===`constructor`||e===`prototype`)throw Error(`Invalid key in path: ${e}`);let s=r;for(let e=0;e<o.length-1;e++){let t=o[e],r=o[e+1];s[t]===null&&(s[t]=n(r)?[]:{}),s=s[t]}let c=o.at(-1);return c&&(s[c]=a),r}export{r as setField};
+import { toPath } from "./to-path.mjs";
+import { isString } from "./type-checks/src/is-string.mjs";
+import { isObjectIndex } from "./type-checks/src/is-object-index.mjs";
+
+//#region src/set-field.ts
+/**
+* Sets a value at a given deep path in an object.
+*
+* @param object - The object to set the value in.
+* @param path - The deep path to set the value at.
+* @param value - The value to set.
+* @returns The object with the value set at the given deep path.
+*/
+function setField(object, path, value) {
+	const resolvedPath = Array.isArray(path) ? path : isString(path) ? toPath(path) : [path];
+	for (const key of resolvedPath) if (key === "__proto__" || key === "constructor" || key === "prototype") throw new Error(`Invalid key in path: ${key}`);
+	let current = object;
+	for (let i = 0; i < resolvedPath.length - 1; i++) {
+		const key = resolvedPath[i];
+		const nextKey = resolvedPath[i + 1];
+		if (current[key] === null) current[key] = isObjectIndex(nextKey) ? [] : {};
+		current = current[key];
+	}
+	const lastKey = resolvedPath.at(-1);
+	if (lastKey) current[lastKey] = value;
+	return object;
+}
+
+//#endregion
+export { setField };
 //# sourceMappingURL=set-field.mjs.map

package/dist/set-field.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"set-field.mjs","names":["current: any"],"sources":["../src/set-field.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\nimport { isObjectIndex } from \"@stryke/type-checks/is-object-index\";\nimport { isString } from \"@stryke/type-checks/is-string\";\nimport type { DeepKey } from \"@stryke/types/object\";\nimport { toPath } from \"./to-path\";\n\n/**\n * Sets a value at a given deep path in an object.\n *\n * @param object - The object to set the value in.\n * @param path - The deep path to set the value at.\n * @param value - The value to set.\n * @returns The object with the value set at the given deep path.\n */\nexport function setField<\n  TObject extends Record<string, any> = Record<string, any>\n>(object: TObject, path: DeepKey<TObject>, value: unknown): TObject {\n  const resolvedPath = Array.isArray(path)\n    ? path\n    : isString(path)\n      ? toPath(path)\n      : [path];\n\n  // Validate resolvedPath to prevent prototype pollution\n  for (const key of resolvedPath) {\n    if (key === \"__proto__\" || key === \"constructor\" || key === \"prototype\") {\n      throw new Error(`Invalid key in path: ${key}`);\n    }\n  }\n\n  let current: any = object;\n  for (let i = 0; i < resolvedPath.length - 1; i++) {\n    const key = resolvedPath[i];\n    const nextKey = resolvedPath[i + 1];\n\n    if (current[key] === null) {\n      current[key] = isObjectIndex(nextKey) ? [] : {};\n    }\n\n    current = current[key];\n  }\n\n  const lastKey = resolvedPath.at(-1);\n  if (lastKey) {\n    current[lastKey] = value;\n  }\n\n  return object;\n}\n"],"mappings":"wKA8BA,SAAgB,EAEd,EAAiB,EAAwB,EAAyB,CAClE,IAAM,EAAe,MAAM,QAAQ,EAAK,CACpC,EACA,EAAS,EAAK,CACZ,EAAO,EAAK,CACZ,CAAC,EAAK,CAGZ,IAAK,IAAM,KAAO,EAChB,GAAI,IAAQ,aAAe,IAAQ,eAAiB,IAAQ,YAC1D,MAAU,MAAM,wBAAwB,IAAM,CAIlD,IAAIA,EAAe,EACnB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAa,OAAS,EAAG,IAAK,CAChD,IAAM,EAAM,EAAa,GACnB,EAAU,EAAa,EAAI,GAE7B,EAAQ,KAAS,OACnB,EAAQ,GAAO,EAAc,EAAQ,CAAG,EAAE,CAAG,EAAE,EAGjD,EAAU,EAAQ,GAGpB,IAAM,EAAU,EAAa,GAAG,GAAG,CAKnC,OAJI,IACF,EAAQ,GAAW,GAGd"}
+{"version":3,"file":"set-field.mjs","names":["current: any"],"sources":["../src/set-field.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\nimport { isObjectIndex } from \"@stryke/type-checks/is-object-index\";\nimport { isString } from \"@stryke/type-checks/is-string\";\nimport type { DeepKey } from \"@stryke/types/object\";\nimport { toPath } from \"./to-path\";\n\n/**\n * Sets a value at a given deep path in an object.\n *\n * @param object - The object to set the value in.\n * @param path - The deep path to set the value at.\n * @param value - The value to set.\n * @returns The object with the value set at the given deep path.\n */\nexport function setField<\n  TObject extends Record<string, any> = Record<string, any>\n>(object: TObject, path: DeepKey<TObject>, value: unknown): TObject {\n  const resolvedPath = Array.isArray(path)\n    ? path\n    : isString(path)\n      ? toPath(path)\n      : [path];\n\n  // Validate resolvedPath to prevent prototype pollution\n  for (const key of resolvedPath) {\n    if (key === \"__proto__\" || key === \"constructor\" || key === \"prototype\") {\n      throw new Error(`Invalid key in path: ${key}`);\n    }\n  }\n\n  let current: any = object;\n  for (let i = 0; i < resolvedPath.length - 1; i++) {\n    const key = resolvedPath[i];\n    const nextKey = resolvedPath[i + 1];\n\n    if (current[key] === null) {\n      current[key] = isObjectIndex(nextKey) ? [] : {};\n    }\n\n    current = current[key];\n  }\n\n  const lastKey = resolvedPath.at(-1);\n  if (lastKey) {\n    current[lastKey] = value;\n  }\n\n  return object;\n}\n"],"mappings":";;;;;;;;;;;;;AA8BA,SAAgB,SAEd,QAAiB,MAAwB,OAAyB;CAClE,MAAM,eAAe,MAAM,QAAQ,KAAK,GACpC,OACA,SAAS,KAAK,GACZ,OAAO,KAAK,GACZ,CAAC,KAAK;AAGZ,MAAK,MAAM,OAAO,aAChB,KAAI,QAAQ,eAAe,QAAQ,iBAAiB,QAAQ,YAC1D,OAAM,IAAI,MAAM,wBAAwB,MAAM;CAIlD,IAAIA,UAAe;AACnB,MAAK,IAAI,IAAI,GAAG,IAAI,aAAa,SAAS,GAAG,KAAK;EAChD,MAAM,MAAM,aAAa;EACzB,MAAM,UAAU,aAAa,IAAI;AAEjC,MAAI,QAAQ,SAAS,KACnB,SAAQ,OAAO,cAAc,QAAQ,GAAG,EAAE,GAAG,EAAE;AAGjD,YAAU,QAAQ;;CAGpB,MAAM,UAAU,aAAa,GAAG,GAAG;AACnC,KAAI,QACF,SAAQ,WAAW;AAGrB,QAAO"}

package/dist/throttle.cjs

@@ -1 +1,43 @@
-function e(e,t){let n;return((...r)=>{let i=Date.now();(n==null||i-n>=t)&&(n=i,e(...r))})}exports.throttle=e;
+
+//#region src/throttle.ts
+/**
+* Creates a throttled function that only invokes the provided function at most once
+* per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+* within the wait time will not trigger the execution of the original function.
+*
+* @example
+* ```typescript
+* const throttledFunction = throttle(() => {
+*   console.log('Function executed');
+* }, 1000);
+*
+* // Will log 'Function executed' immediately
+* throttledFunction();
+*
+* // Will not log anything as it is within the throttle time
+* throttledFunction();
+*
+* // After 1 second
+* setTimeout(() => {
+*   throttledFunction(); // Will log 'Function executed'
+* }, 1000);
+* ```
+*
+* @param func - The function to throttle.
+* @param throttleMs - The number of milliseconds to throttle executions to.
+* @returns A new throttled function that accepts the same parameters as the original function.
+*/
+function throttle(func, throttleMs) {
+	let lastCallTime;
+	const throttledFunction = ((...args) => {
+		const now = Date.now();
+		if (lastCallTime == null || now - lastCallTime >= throttleMs) {
+			lastCallTime = now;
+			func(...args);
+		}
+	});
+	return throttledFunction;
+}
+
+//#endregion
+exports.throttle = throttle;

package/dist/throttle.mjs

@@ -1,2 +1,43 @@
-function e(e,t){let n;return((...r)=>{let i=Date.now();(n==null||i-n>=t)&&(n=i,e(...r))})}export{e as throttle};
+//#region src/throttle.ts
+/**
+* Creates a throttled function that only invokes the provided function at most once
+* per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+* within the wait time will not trigger the execution of the original function.
+*
+* @example
+* ```typescript
+* const throttledFunction = throttle(() => {
+*   console.log('Function executed');
+* }, 1000);
+*
+* // Will log 'Function executed' immediately
+* throttledFunction();
+*
+* // Will not log anything as it is within the throttle time
+* throttledFunction();
+*
+* // After 1 second
+* setTimeout(() => {
+*   throttledFunction(); // Will log 'Function executed'
+* }, 1000);
+* ```
+*
+* @param func - The function to throttle.
+* @param throttleMs - The number of milliseconds to throttle executions to.
+* @returns A new throttled function that accepts the same parameters as the original function.
+*/
+function throttle(func, throttleMs) {
+	let lastCallTime;
+	const throttledFunction = ((...args) => {
+		const now = Date.now();
+		if (lastCallTime == null || now - lastCallTime >= throttleMs) {
+			lastCallTime = now;
+			func(...args);
+		}
+	});
+	return throttledFunction;
+}
+
+//#endregion
+export { throttle };
 //# sourceMappingURL=throttle.mjs.map

package/dist/throttle.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"throttle.mjs","names":["lastCallTime: number | null"],"sources":["../src/throttle.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\n/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @example\n * ```typescript\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n * ```\n *\n * @param func - The function to throttle.\n * @param throttleMs - The number of milliseconds to throttle executions to.\n * @returns A new throttled function that accepts the same parameters as the original function.\n */\nexport function throttle<F extends (...args: any[]) => void>(\n  func: F,\n  throttleMs: number\n): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = ((...args: Parameters<F>) => {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  }) as F;\n\n  return throttledFunction;\n}\n"],"mappings":"AA4CA,SAAgB,EACd,EACA,EACG,CACH,IAAIA,EAWJ,QAT4B,GAAG,IAAwB,CACrD,IAAM,EAAM,KAAK,KAAK,EAElB,GAAgB,MAAQ,EAAM,GAAgB,KAChD,EAAe,EACf,EAAK,GAAG,EAAK"}
+{"version":3,"file":"throttle.mjs","names":["lastCallTime: number | null"],"sources":["../src/throttle.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\n/**\n * Creates a throttled function that only invokes the provided function at most once\n * per every `throttleMs` milliseconds. Subsequent calls to the throttled function\n * within the wait time will not trigger the execution of the original function.\n *\n * @example\n * ```typescript\n * const throttledFunction = throttle(() => {\n *   console.log('Function executed');\n * }, 1000);\n *\n * // Will log 'Function executed' immediately\n * throttledFunction();\n *\n * // Will not log anything as it is within the throttle time\n * throttledFunction();\n *\n * // After 1 second\n * setTimeout(() => {\n *   throttledFunction(); // Will log 'Function executed'\n * }, 1000);\n * ```\n *\n * @param func - The function to throttle.\n * @param throttleMs - The number of milliseconds to throttle executions to.\n * @returns A new throttled function that accepts the same parameters as the original function.\n */\nexport function throttle<F extends (...args: any[]) => void>(\n  func: F,\n  throttleMs: number\n): F {\n  let lastCallTime: number | null;\n\n  const throttledFunction = ((...args: Parameters<F>) => {\n    const now = Date.now();\n\n    if (lastCallTime == null || now - lastCallTime >= throttleMs) {\n      lastCallTime = now;\n      func(...args);\n    }\n  }) as F;\n\n  return throttledFunction;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAgB,SACd,MACA,YACG;CACH,IAAIA;CAEJ,MAAM,sBAAsB,GAAG,SAAwB;EACrD,MAAM,MAAM,KAAK,KAAK;AAEtB,MAAI,gBAAgB,QAAQ,MAAM,gBAAgB,YAAY;AAC5D,kBAAe;AACf,QAAK,GAAG,KAAK;;;AAIjB,QAAO"}

package/dist/timeout.cjs

@@ -1 +1,18 @@
-const e=require(`./errors.cjs`),t=require(`./delay.cjs`);async function n(n){throw await t.delay(n),new e.TimeoutError}exports.timeout=n;
+const require_errors = require('./errors.cjs');
+const require_delay = require('./delay.cjs');
+
+//#region src/timeout.ts
+/**
+* Returns a promise that rejects with a `TimeoutError` after a specified delay.
+*
+* @param ms - The delay duration in milliseconds.
+* @returns A promise that rejects with a `TimeoutError` after the specified delay.
+* @throws Throws a `TimeoutError` after the specified delay.
+*/
+async function timeout(ms) {
+	await require_delay.delay(ms);
+	throw new require_errors.TimeoutError();
+}
+
+//#endregion
+exports.timeout = timeout;

package/dist/timeout.mjs

@@ -1,2 +1,19 @@
-import{TimeoutError as e}from"./errors.mjs";import{delay as t}from"./delay.mjs";async function n(n){throw await t(n),new e}export{n as timeout};
+import { TimeoutError } from "./errors.mjs";
+import { delay } from "./delay.mjs";
+
+//#region src/timeout.ts
+/**
+* Returns a promise that rejects with a `TimeoutError` after a specified delay.
+*
+* @param ms - The delay duration in milliseconds.
+* @returns A promise that rejects with a `TimeoutError` after the specified delay.
+* @throws Throws a `TimeoutError` after the specified delay.
+*/
+async function timeout(ms) {
+	await delay(ms);
+	throw new TimeoutError();
+}
+
+//#endregion
+export { timeout };
 //# sourceMappingURL=timeout.mjs.map

package/dist/timeout.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"timeout.mjs","names":[],"sources":["../src/timeout.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\nimport { delay } from \"./delay\";\nimport { TimeoutError } from \"./errors\";\n\n/**\n * Returns a promise that rejects with a `TimeoutError` after a specified delay.\n *\n * @param ms - The delay duration in milliseconds.\n * @returns A promise that rejects with a `TimeoutError` after the specified delay.\n * @throws Throws a `TimeoutError` after the specified delay.\n */\nexport async function timeout(ms: number): Promise<never> {\n  await delay(ms);\n  throw new TimeoutError();\n}\n"],"mappings":"gFA2BA,eAAsB,EAAQ,EAA4B,CAExD,MADA,MAAM,EAAM,EAAG,CACT,IAAI"}
+{"version":3,"file":"timeout.mjs","names":[],"sources":["../src/timeout.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\nimport { delay } from \"./delay\";\nimport { TimeoutError } from \"./errors\";\n\n/**\n * Returns a promise that rejects with a `TimeoutError` after a specified delay.\n *\n * @param ms - The delay duration in milliseconds.\n * @returns A promise that rejects with a `TimeoutError` after the specified delay.\n * @throws Throws a `TimeoutError` after the specified delay.\n */\nexport async function timeout(ms: number): Promise<never> {\n  await delay(ms);\n  throw new TimeoutError();\n}\n"],"mappings":";;;;;;;;;;;AA2BA,eAAsB,QAAQ,IAA4B;AACxD,OAAM,MAAM,GAAG;AACf,OAAM,IAAI,cAAc"}

package/dist/to-deep-key.cjs

@@ -1 +1,54 @@
-const e=require(`./type-checks/src/is-number.cjs`),t=require(`./type-checks/src/is-set-string.cjs`);function n(e){return e.reduce((e,t)=>r(e,t))}function r(n,r){return e.isNumber(r)||Number.isInteger(r)?`${n}[${r}]`:t.isSetString(r)?`${n}.${r}`:n}exports.addPathToDeepKey=r,exports.toDeepKey=n;
+const require_is_number = require('./type-checks/src/is-number.cjs');
+const require_is_set_string = require('./type-checks/src/is-set-string.cjs');
+
+//#region src/to-deep-key.ts
+/**
+* Converts an array of path segments into a deep key string.
+*
+* This function takes an array of strings and numbers representing path segments and combines them into a deep key string.
+*
+* @example
+* toDeepKey(['a', 'b', 'c']) // Returns 'a.b.c'
+* toDeepKey(['a', 0, 'c']) // Returns 'a[0].c'
+* toDeepKey(['', 'a', 'b', 'c']) // Returns '.a.b.c'
+* toDeepKey(['a', 'b.c', 'd']) // Returns 'a.b.c.d'
+* toDeepKey([]) // Returns ''
+* toDeepKey(['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']) // Returns '.a.b.c.d.e.f.g.h'
+*
+* @param path - An array of strings and numbers representing path segments.
+* @returns A deep key string.
+*/
+function toDeepKey(path) {
+	return path.reduce((ret, segment) => {
+		return addPathToDeepKey(ret, segment);
+	});
+}
+/**
+* Adds a path segment to a deep key string.
+*
+* @remarks
+* This function takes a deep key string and a path segment and combines them into a new deep key string.
+*
+* @example
+* ```ts
+* addPathToDeepKey('a.b', 'c') // Returns 'a.b.c'
+* addPathToDeepKey('a[0]', 'c') // Returns 'a[0].c'
+* addPathToDeepKey('.a.b', 'c') // Returns '.a.b.c'
+* addPathToDeepKey('a.b', 'b.c') // Returns 'a.b.b.c'
+* addPathToDeepKey('', 'a') // Returns 'a'
+* addPathToDeepKey('.a.b', 'c.d') // Returns '.a.b.c.d'
+* ```
+*
+* @param deepKey - The deep key string to add the path segment to.
+* @param path - The path segment to add to the deep key string.
+* @returns A new deep key string.
+*/
+function addPathToDeepKey(deepKey, path) {
+	if (require_is_number.isNumber(path) || Number.isInteger(path)) return `${deepKey}[${path}]`;
+	if (require_is_set_string.isSetString(path)) return `${deepKey}.${path}`;
+	return deepKey;
+}
+
+//#endregion
+exports.addPathToDeepKey = addPathToDeepKey;
+exports.toDeepKey = toDeepKey;

package/dist/to-deep-key.mjs

@@ -1,2 +1,54 @@
-import{isNumber as e}from"./type-checks/src/is-number.mjs";import{isSetString as t}from"./type-checks/src/is-set-string.mjs";function n(e){return e.reduce((e,t)=>r(e,t))}function r(n,r){return e(r)||Number.isInteger(r)?`${n}[${r}]`:t(r)?`${n}.${r}`:n}export{r as addPathToDeepKey,n as toDeepKey};
+import { isNumber } from "./type-checks/src/is-number.mjs";
+import { isSetString } from "./type-checks/src/is-set-string.mjs";
+
+//#region src/to-deep-key.ts
+/**
+* Converts an array of path segments into a deep key string.
+*
+* This function takes an array of strings and numbers representing path segments and combines them into a deep key string.
+*
+* @example
+* toDeepKey(['a', 'b', 'c']) // Returns 'a.b.c'
+* toDeepKey(['a', 0, 'c']) // Returns 'a[0].c'
+* toDeepKey(['', 'a', 'b', 'c']) // Returns '.a.b.c'
+* toDeepKey(['a', 'b.c', 'd']) // Returns 'a.b.c.d'
+* toDeepKey([]) // Returns ''
+* toDeepKey(['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']) // Returns '.a.b.c.d.e.f.g.h'
+*
+* @param path - An array of strings and numbers representing path segments.
+* @returns A deep key string.
+*/
+function toDeepKey(path) {
+	return path.reduce((ret, segment) => {
+		return addPathToDeepKey(ret, segment);
+	});
+}
+/**
+* Adds a path segment to a deep key string.
+*
+* @remarks
+* This function takes a deep key string and a path segment and combines them into a new deep key string.
+*
+* @example
+* ```ts
+* addPathToDeepKey('a.b', 'c') // Returns 'a.b.c'
+* addPathToDeepKey('a[0]', 'c') // Returns 'a[0].c'
+* addPathToDeepKey('.a.b', 'c') // Returns '.a.b.c'
+* addPathToDeepKey('a.b', 'b.c') // Returns 'a.b.b.c'
+* addPathToDeepKey('', 'a') // Returns 'a'
+* addPathToDeepKey('.a.b', 'c.d') // Returns '.a.b.c.d'
+* ```
+*
+* @param deepKey - The deep key string to add the path segment to.
+* @param path - The path segment to add to the deep key string.
+* @returns A new deep key string.
+*/
+function addPathToDeepKey(deepKey, path) {
+	if (isNumber(path) || Number.isInteger(path)) return `${deepKey}[${path}]`;
+	if (isSetString(path)) return `${deepKey}.${path}`;
+	return deepKey;
+}
+
+//#endregion
+export { addPathToDeepKey, toDeepKey };
 //# sourceMappingURL=to-deep-key.mjs.map

package/dist/to-deep-key.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"to-deep-key.mjs","names":[],"sources":["../src/to-deep-key.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\nimport { isNumber } from \"@stryke/type-checks/is-number\";\nimport { isSetString } from \"@stryke/type-checks/is-set-string\";\n\n/**\n * Converts an array of path segments into a deep key string.\n *\n * This function takes an array of strings and numbers representing path segments and combines them into a deep key string.\n *\n * @example\n * toDeepKey(['a', 'b', 'c']) // Returns 'a.b.c'\n * toDeepKey(['a', 0, 'c']) // Returns 'a[0].c'\n * toDeepKey(['', 'a', 'b', 'c']) // Returns '.a.b.c'\n * toDeepKey(['a', 'b.c', 'd']) // Returns 'a.b.c.d'\n * toDeepKey([]) // Returns ''\n * toDeepKey(['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']) // Returns '.a.b.c.d.e.f.g.h'\n *\n * @param path - An array of strings and numbers representing path segments.\n * @returns A deep key string.\n */\nexport function toDeepKey(path: string[]): string {\n  return path.reduce((ret, segment) => {\n    return addPathToDeepKey(ret, segment);\n  });\n}\n\n/**\n * Adds a path segment to a deep key string.\n *\n * @remarks\n * This function takes a deep key string and a path segment and combines them into a new deep key string.\n *\n * @example\n * ```ts\n * addPathToDeepKey('a.b', 'c') // Returns 'a.b.c'\n * addPathToDeepKey('a[0]', 'c') // Returns 'a[0].c'\n * addPathToDeepKey('.a.b', 'c') // Returns '.a.b.c'\n * addPathToDeepKey('a.b', 'b.c') // Returns 'a.b.b.c'\n * addPathToDeepKey('', 'a') // Returns 'a'\n * addPathToDeepKey('.a.b', 'c.d') // Returns '.a.b.c.d'\n * ```\n *\n * @param deepKey - The deep key string to add the path segment to.\n * @param path - The path segment to add to the deep key string.\n * @returns A new deep key string.\n */\nexport function addPathToDeepKey(\n  deepKey: string,\n  path: string | number\n): string {\n  if (isNumber(path) || Number.isInteger(path)) {\n    return `${deepKey}[${path}]`;\n  }\n  if (isSetString(path)) {\n    return `${deepKey}.${path}`;\n  }\n\n  return deepKey;\n}\n"],"mappings":"6HAoCA,SAAgB,EAAU,EAAwB,CAChD,OAAO,EAAK,QAAQ,EAAK,IAChB,EAAiB,EAAK,EAAQ,CACrC,CAuBJ,SAAgB,EACd,EACA,EACQ,CAQR,OAPI,EAAS,EAAK,EAAI,OAAO,UAAU,EAAK,CACnC,GAAG,EAAQ,GAAG,EAAK,GAExB,EAAY,EAAK,CACZ,GAAG,EAAQ,GAAG,IAGhB"}
+{"version":3,"file":"to-deep-key.mjs","names":[],"sources":["../src/to-deep-key.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 License, and is\n free for commercial and private use. For more information, please visit\n our licensing page.\n\n Website:         https://stormsoftware.com\n Repository:      https://github.com/storm-software/stryke\n Documentation:   https://stormsoftware.com/projects/stryke/docs\n Contact:         https://stormsoftware.com/contact\n License:         https://stormsoftware.com/projects/stryke/license\n\n ------------------------------------------------------------------- */\n\nimport { isNumber } from \"@stryke/type-checks/is-number\";\nimport { isSetString } from \"@stryke/type-checks/is-set-string\";\n\n/**\n * Converts an array of path segments into a deep key string.\n *\n * This function takes an array of strings and numbers representing path segments and combines them into a deep key string.\n *\n * @example\n * toDeepKey(['a', 'b', 'c']) // Returns 'a.b.c'\n * toDeepKey(['a', 0, 'c']) // Returns 'a[0].c'\n * toDeepKey(['', 'a', 'b', 'c']) // Returns '.a.b.c'\n * toDeepKey(['a', 'b.c', 'd']) // Returns 'a.b.c.d'\n * toDeepKey([]) // Returns ''\n * toDeepKey(['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']) // Returns '.a.b.c.d.e.f.g.h'\n *\n * @param path - An array of strings and numbers representing path segments.\n * @returns A deep key string.\n */\nexport function toDeepKey(path: string[]): string {\n  return path.reduce((ret, segment) => {\n    return addPathToDeepKey(ret, segment);\n  });\n}\n\n/**\n * Adds a path segment to a deep key string.\n *\n * @remarks\n * This function takes a deep key string and a path segment and combines them into a new deep key string.\n *\n * @example\n * ```ts\n * addPathToDeepKey('a.b', 'c') // Returns 'a.b.c'\n * addPathToDeepKey('a[0]', 'c') // Returns 'a[0].c'\n * addPathToDeepKey('.a.b', 'c') // Returns '.a.b.c'\n * addPathToDeepKey('a.b', 'b.c') // Returns 'a.b.b.c'\n * addPathToDeepKey('', 'a') // Returns 'a'\n * addPathToDeepKey('.a.b', 'c.d') // Returns '.a.b.c.d'\n * ```\n *\n * @param deepKey - The deep key string to add the path segment to.\n * @param path - The path segment to add to the deep key string.\n * @returns A new deep key string.\n */\nexport function addPathToDeepKey(\n  deepKey: string,\n  path: string | number\n): string {\n  if (isNumber(path) || Number.isInteger(path)) {\n    return `${deepKey}[${path}]`;\n  }\n  if (isSetString(path)) {\n    return `${deepKey}.${path}`;\n  }\n\n  return deepKey;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoCA,SAAgB,UAAU,MAAwB;AAChD,QAAO,KAAK,QAAQ,KAAK,YAAY;AACnC,SAAO,iBAAiB,KAAK,QAAQ;GACrC;;;;;;;;;;;;;;;;;;;;;;AAuBJ,SAAgB,iBACd,SACA,MACQ;AACR,KAAI,SAAS,KAAK,IAAI,OAAO,UAAU,KAAK,CAC1C,QAAO,GAAG,QAAQ,GAAG,KAAK;AAE5B,KAAI,YAAY,KAAK,CACnB,QAAO,GAAG,QAAQ,GAAG;AAGvB,QAAO"}

package/dist/to-path.cjs

@@ -1 +1,43 @@
-const e=/^[\w.]+$/g,t=/\\(?<temp1>\\)?/g,n=RegExp(`${String.raw`[^.[\]]+`}|${String.raw`\[(?:`}([^"'][^[]*)|${String.raw`(["'])((?:(?!\2)[^\\]|\\.)*?)\2`}${String.raw`)\]`}|${String.raw`(?=(?:\.|\[\])(?:\.|\[\]|$))`}`,`g`);function r(r){if(e.test(r))return r.split(`.`);let i=[];r[0]===`.`&&i.push(``);let a=r.matchAll(n);for(let e of a){let n=e[0],r=e[1],a=e[2],o=e[3];a&&o?n=o.replace(t,`$1`):r&&(n=r),i.push(n)}return i}exports.toPath=r;
+
+//#region src/to-path.ts
+const DOTS_KEY = /^[\w.]+$/g;
+const ESCAPE_REGEXP = /\\(?<temp1>\\)?/g;
+const PROPERTY_REGEXP = new RegExp(`${String.raw`[^.[\]]+`}|${String.raw`\[(?:`}([^"'][^[]*)|${String.raw`(["'])((?:(?!\2)[^\\]|\\.)*?)\2`}${String.raw`)\]`}|${String.raw`(?=(?:\.|\[\])(?:\.|\[\]|$))`}`, "g");
+/**
+* Converts a deep key string into an array of path segments.
+*
+* @remarks
+* This function takes a string representing a deep key (e.g., 'a.b.c' or 'a[b][c]') and breaks it down into an array of strings, each representing a segment of the path.
+*
+* @example
+* ```ts
+* toPath('a.b.c') // Returns ['a', 'b', 'c']
+* toPath('a[b][c]') // Returns ['a', 'b', 'c']
+* toPath('.a.b.c') // Returns ['', 'a', 'b', 'c']
+* toPath('a["b.c"].d') // Returns ['a', 'b.c', 'd']
+* toPath('') // Returns []
+* toPath('.a[b].c.d[e]["f.g"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']
+* ```
+*
+* @param deepKey - The deep key string to convert.
+* @returns An array of strings, each representing a segment of the path.
+*/
+function toPath(deepKey) {
+	if (DOTS_KEY.test(deepKey)) return deepKey.split(".");
+	const result = [];
+	if (deepKey[0] === ".") result.push("");
+	const matches = deepKey.matchAll(PROPERTY_REGEXP);
+	for (const match of matches) {
+		let key = match[0];
+		const expr = match[1];
+		const quote = match[2];
+		const substr = match[3];
+		if (quote && substr) key = substr.replace(ESCAPE_REGEXP, "$1");
+		else if (expr) key = expr;
+		result.push(key);
+	}
+	return result;
+}
+
+//#endregion
+exports.toPath = toPath;

package/dist/to-path.mjs

@@ -1,2 +1,43 @@
-const e=/^[\w.]+$/g,t=/\\(?<temp1>\\)?/g,n=RegExp(`${String.raw`[^.[\]]+`}|${String.raw`\[(?:`}([^"'][^[]*)|${String.raw`(["'])((?:(?!\2)[^\\]|\\.)*?)\2`}${String.raw`)\]`}|${String.raw`(?=(?:\.|\[\])(?:\.|\[\]|$))`}`,`g`);function r(r){if(e.test(r))return r.split(`.`);let i=[];r[0]===`.`&&i.push(``);let a=r.matchAll(n);for(let e of a){let n=e[0],r=e[1],a=e[2],o=e[3];a&&o?n=o.replace(t,`$1`):r&&(n=r),i.push(n)}return i}export{r as toPath};
+//#region src/to-path.ts
+const DOTS_KEY = /^[\w.]+$/g;
+const ESCAPE_REGEXP = /\\(?<temp1>\\)?/g;
+const PROPERTY_REGEXP = new RegExp(`${String.raw`[^.[\]]+`}|${String.raw`\[(?:`}([^"'][^[]*)|${String.raw`(["'])((?:(?!\2)[^\\]|\\.)*?)\2`}${String.raw`)\]`}|${String.raw`(?=(?:\.|\[\])(?:\.|\[\]|$))`}`, "g");
+/**
+* Converts a deep key string into an array of path segments.
+*
+* @remarks
+* This function takes a string representing a deep key (e.g., 'a.b.c' or 'a[b][c]') and breaks it down into an array of strings, each representing a segment of the path.
+*
+* @example
+* ```ts
+* toPath('a.b.c') // Returns ['a', 'b', 'c']
+* toPath('a[b][c]') // Returns ['a', 'b', 'c']
+* toPath('.a.b.c') // Returns ['', 'a', 'b', 'c']
+* toPath('a["b.c"].d') // Returns ['a', 'b.c', 'd']
+* toPath('') // Returns []
+* toPath('.a[b].c.d[e]["f.g"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']
+* ```
+*
+* @param deepKey - The deep key string to convert.
+* @returns An array of strings, each representing a segment of the path.
+*/
+function toPath(deepKey) {
+	if (DOTS_KEY.test(deepKey)) return deepKey.split(".");
+	const result = [];
+	if (deepKey[0] === ".") result.push("");
+	const matches = deepKey.matchAll(PROPERTY_REGEXP);
+	for (const match of matches) {
+		let key = match[0];
+		const expr = match[1];
+		const quote = match[2];
+		const substr = match[3];
+		if (quote && substr) key = substr.replace(ESCAPE_REGEXP, "$1");
+		else if (expr) key = expr;
+		result.push(key);
+	}
+	return result;
+}
+
+//#endregion
+export { toPath };
 //# sourceMappingURL=to-path.mjs.map

package/dist/to-path.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"to-path.mjs","names":["result: string[]"],"sources":["../src/to-path.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nconst DOTS_KEY = /^[\\w.]+$/g;\n\nconst ESCAPE_REGEXP = /\\\\(?<temp1>\\\\)?/g;\nconst PROPERTY_REGEXP = new RegExp(\n  // Match anything that isn't a dot or bracket.\n  `${String.raw`[^.[\\]]+`}|${\n    // Or match property names within brackets.\n    String.raw`\\[(?:`\n    // Match a non-string expression.\n  }([^\"'][^[]*)` +\n    `|${\n      // Or match strings (supports escaping characters).\n      String.raw`([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2`\n    }${String.raw`)\\]`}|${\n      // Or match \"\" as the space between consecutive dots or empty brackets.\n      String.raw`(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))`\n    }`,\n  \"g\"\n);\n\n/**\n * Converts a deep key string into an array of path segments.\n *\n * @remarks\n * This function takes a string representing a deep key (e.g., 'a.b.c' or 'a[b][c]') and breaks it down into an array of strings, each representing a segment of the path.\n *\n * @example\n * ```ts\n * toPath('a.b.c') // Returns ['a', 'b', 'c']\n * toPath('a[b][c]') // Returns ['a', 'b', 'c']\n * toPath('.a.b.c') // Returns ['', 'a', 'b', 'c']\n * toPath('a[\"b.c\"].d') // Returns ['a', 'b.c', 'd']\n * toPath('') // Returns []\n * toPath('.a[b].c.d[e][\"f.g\"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']\n * ```\n *\n * @param deepKey - The deep key string to convert.\n * @returns An array of strings, each representing a segment of the path.\n */\nexport function toPath(deepKey: string): string[] {\n  if (DOTS_KEY.test(deepKey)) {\n    return deepKey.split(\".\");\n  }\n\n  const result: string[] = [];\n\n  if (deepKey[0] === \".\") {\n    result.push(\"\");\n  }\n\n  const matches = deepKey.matchAll(PROPERTY_REGEXP);\n\n  for (const match of matches) {\n    let key = match[0];\n    const expr = match[1];\n    const quote = match[2];\n    const substr = match[3];\n\n    if (quote && substr) {\n      key = substr.replace(ESCAPE_REGEXP, \"$1\");\n    } else if (expr) {\n      key = expr;\n    }\n\n    result.push(key);\n  }\n\n  return result;\n}\n"],"mappings":"AAkBA,MAAM,EAAW,YAEX,EAAgB,mBAChB,EAAsB,OAE1B,GAAG,OAAO,GAAG,WAAW,GAEtB,OAAO,GAAG,QAEX,eAGG,OAAO,GAAG,oCACT,OAAO,GAAG,MAAM,GAEjB,OAAO,GAAG,iCAEd,IACD,CAqBD,SAAgB,EAAO,EAA2B,CAChD,GAAI,EAAS,KAAK,EAAQ,CACxB,OAAO,EAAQ,MAAM,IAAI,CAG3B,IAAMA,EAAmB,EAAE,CAEvB,EAAQ,KAAO,KACjB,EAAO,KAAK,GAAG,CAGjB,IAAM,EAAU,EAAQ,SAAS,EAAgB,CAEjD,IAAK,IAAM,KAAS,EAAS,CAC3B,IAAI,EAAM,EAAM,GACV,EAAO,EAAM,GACb,EAAQ,EAAM,GACd,EAAS,EAAM,GAEjB,GAAS,EACX,EAAM,EAAO,QAAQ,EAAe,KAAK,CAChC,IACT,EAAM,GAGR,EAAO,KAAK,EAAI,CAGlB,OAAO"}
+{"version":3,"file":"to-path.mjs","names":["result: string[]"],"sources":["../src/to-path.ts"],"sourcesContent":["/* -------------------------------------------------------------------\n\n                       ⚡ Storm Software - Stryke\n\n This code was released as part of the Stryke project. Stryke\n is maintained by Storm Software under the Apache-2.0 license, and is\n free for commercial and private use. For more information, please visit\n our licensing page at https://stormsoftware.com/licenses/projects/stryke.\n\n Website:                  https://stormsoftware.com\n Repository:               https://github.com/storm-software/stryke\n Documentation:            https://docs.stormsoftware.com/projects/stryke\n Contact:                  https://stormsoftware.com/contact\n\n SPDX-License-Identifier:  Apache-2.0\n\n ------------------------------------------------------------------- */\n\nconst DOTS_KEY = /^[\\w.]+$/g;\n\nconst ESCAPE_REGEXP = /\\\\(?<temp1>\\\\)?/g;\nconst PROPERTY_REGEXP = new RegExp(\n  // Match anything that isn't a dot or bracket.\n  `${String.raw`[^.[\\]]+`}|${\n    // Or match property names within brackets.\n    String.raw`\\[(?:`\n    // Match a non-string expression.\n  }([^\"'][^[]*)` +\n    `|${\n      // Or match strings (supports escaping characters).\n      String.raw`([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2`\n    }${String.raw`)\\]`}|${\n      // Or match \"\" as the space between consecutive dots or empty brackets.\n      String.raw`(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))`\n    }`,\n  \"g\"\n);\n\n/**\n * Converts a deep key string into an array of path segments.\n *\n * @remarks\n * This function takes a string representing a deep key (e.g., 'a.b.c' or 'a[b][c]') and breaks it down into an array of strings, each representing a segment of the path.\n *\n * @example\n * ```ts\n * toPath('a.b.c') // Returns ['a', 'b', 'c']\n * toPath('a[b][c]') // Returns ['a', 'b', 'c']\n * toPath('.a.b.c') // Returns ['', 'a', 'b', 'c']\n * toPath('a[\"b.c\"].d') // Returns ['a', 'b.c', 'd']\n * toPath('') // Returns []\n * toPath('.a[b].c.d[e][\"f.g\"].h') // Returns ['', 'a', 'b', 'c', 'd', 'e', 'f.g', 'h']\n * ```\n *\n * @param deepKey - The deep key string to convert.\n * @returns An array of strings, each representing a segment of the path.\n */\nexport function toPath(deepKey: string): string[] {\n  if (DOTS_KEY.test(deepKey)) {\n    return deepKey.split(\".\");\n  }\n\n  const result: string[] = [];\n\n  if (deepKey[0] === \".\") {\n    result.push(\"\");\n  }\n\n  const matches = deepKey.matchAll(PROPERTY_REGEXP);\n\n  for (const match of matches) {\n    let key = match[0];\n    const expr = match[1];\n    const quote = match[2];\n    const substr = match[3];\n\n    if (quote && substr) {\n      key = substr.replace(ESCAPE_REGEXP, \"$1\");\n    } else if (expr) {\n      key = expr;\n    }\n\n    result.push(key);\n  }\n\n  return result;\n}\n"],"mappings":";AAkBA,MAAM,WAAW;AAEjB,MAAM,gBAAgB;AACtB,MAAM,kBAAkB,IAAI,OAE1B,GAAG,OAAO,GAAG,WAAW,GAEtB,OAAO,GAAG,QAEX,eAGG,OAAO,GAAG,oCACT,OAAO,GAAG,MAAM,GAEjB,OAAO,GAAG,kCAEd,IACD;;;;;;;;;;;;;;;;;;;;AAqBD,SAAgB,OAAO,SAA2B;AAChD,KAAI,SAAS,KAAK,QAAQ,CACxB,QAAO,QAAQ,MAAM,IAAI;CAG3B,MAAMA,SAAmB,EAAE;AAE3B,KAAI,QAAQ,OAAO,IACjB,QAAO,KAAK,GAAG;CAGjB,MAAM,UAAU,QAAQ,SAAS,gBAAgB;AAEjD,MAAK,MAAM,SAAS,SAAS;EAC3B,IAAI,MAAM,MAAM;EAChB,MAAM,OAAO,MAAM;EACnB,MAAM,QAAQ,MAAM;EACpB,MAAM,SAAS,MAAM;AAErB,MAAI,SAAS,OACX,OAAM,OAAO,QAAQ,eAAe,KAAK;WAChC,KACT,OAAM;AAGR,SAAO,KAAK,IAAI;;AAGlB,QAAO"}

package/dist/type-checks/src/get-object-tag.cjs

@@ -1 +1,15 @@
-const e=e=>e==null?e===void 0?`[object Undefined]`:`[object Null]`:Object.prototype.toString.call(e);exports.getObjectTag=e;
+
+//#region ../type-checks/src/get-object-tag.ts
+/**
+* Gets the `toStringTag` of `obj`.
+*
+* @param value - The obj to query.
+* @returns Returns the `toStringTag`.
+*/
+const getObjectTag = (value) => {
+	if (value == null) return value === void 0 ? "[object Undefined]" : "[object Null]";
+	return Object.prototype.toString.call(value);
+};
+
+//#endregion
+exports.getObjectTag = getObjectTag;