@difizen/libro-common 0.1.0 → 0.1.1

package/es/array.d.ts

@@ -0,0 +1,368 @@
+/**
+ * Find the index of the first occurrence of a value in an array.
+ *
+ * @param array - The array-like object to search.
+ *
+ * @param value - The value to locate in the array. Values are
+ *   compared using strict `===` equality.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first occurrence of the value, or `-1`
+ *   if the value is not found.
+ *
+ * #### Notes
+ * If `stop < start` the search will wrap at the end of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * let data = ['one', 'two', 'three', 'four', 'one'];
+ * firstIndexOfArray(data, 'red');        // -1
+ * firstIndexOfArray(data, 'one');        // 0
+ * firstIndexOfArray(data, 'one', 1);     // 4
+ * firstIndexOfArray(data, 'two', 2);     // -1
+ * firstIndexOfArray(data, 'two', 2, 1);  // 1
+ * ```
+ */
+export declare function firstIndexOfArray<T>(array: ArrayLike<T>, value: T, start?: number, stop?: number): number;
+/**
+ * Find the index of the first value which matches a predicate.
+ *
+ * @param array - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first matching value, or `-1` if no
+ *   matching value is found.
+ *
+ * #### Notes
+ * If `stop < start` the search will wrap at the end of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findFirstArrayIndex(data, isEven);       // 1
+ * findFirstArrayIndex(data, isEven, 4);    // 5
+ * findFirstArrayIndex(data, isEven, 6);    // -1
+ * findFirstArrayIndex(data, isEven, 6, 5); // 1
+ * ```
+ */
+export declare function findFirstArrayIndex<T>(array: ArrayLike<T>, fn: (value: T, index: number) => boolean, start?: number, stop?: number): number;
+/**
+ * Find the index of the last value which matches a predicate.
+ *
+ * @param object - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the last matching value, or `-1` if no
+ *   matching value is found.
+ *
+ * #### Notes
+ * If `start < stop` the search will wrap at the front of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findLastArrayIndex(data, isEven);        // 5
+ * findLastArrayIndex(data, isEven, 4);     // 3
+ * findLastArrayIndex(data, isEven, 0);     // -1
+ * findLastArrayIndex(data, isEven, 0, 1);  // 5
+ * ```
+ */
+export declare function findLastArrayIndex<T>(array: ArrayLike<T>, fn: (value: T, index: number) => boolean, start?: number, stop?: number): number;
+/**
+ * Find the first value which matches a predicate.
+ *
+ * @param array - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The first matching value, or `undefined` if no matching
+ *   value is found.
+ *
+ * #### Notes
+ * If `stop < start` the search will wrap at the end of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findFirstArrayValue(data, isEven);       // 2
+ * findFirstArrayValue(data, isEven, 2);    // 4
+ * findFirstArrayValue(data, isEven, 6);    // undefined
+ * findFirstArrayValue(data, isEven, 6, 5); // 2
+ * ```
+ */
+export declare function findFirstArrayValue<T>(array: ArrayLike<T>, fn: (value: T, index: number) => boolean, start?: number, stop?: number): T | undefined;
+/**
+ * Find the last value which matches a predicate.
+ *
+ * @param object - The array-like object to search.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The last matching value, or `undefined` if no matching
+ *   value is found.
+ *
+ * #### Notes
+ * If `start < stop` the search will wrap at the front of the array.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Undefined Behavior
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * let data = [1, 2, 3, 4, 3, 2, 1];
+ * findLastArrayValue(data, isEven);        // 2
+ * findLastArrayValue(data, isEven, 4);     // 4
+ * findLastArrayValue(data, isEven, 0);     // undefined
+ * findLastArrayValue(data, isEven, 0, 1);  // 2
+ * ```
+ */
+export declare function findLastArrayValue<T>(array: ArrayLike<T>, fn: (value: T, index: number) => boolean, start?: number, stop?: number): T | undefined;
+/**
+ * Find the index of the first element which compares `>=` to a value.
+ *
+ * @param array - The sorted array-like object to search.
+ *
+ * @param value - The value to locate in the array.
+ *
+ * @param fn - The 3-way comparison function to apply to the values.
+ *   It should return `< 0` if an element is less than a value, `0` if
+ *   an element is equal to a value, or `> 0` if an element is greater
+ *   than a value.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first element which compares `>=` to the
+ *   value, or `length` if there is no such element. If the computed
+ *   index for `stop` is less than `start`, then the computed index
+ *   for `start` is returned.
+ *
+ * #### Notes
+ * The array must already be sorted in ascending order according to
+ * the comparison function.
+ *
+ * #### Complexity
+ * Logarithmic.
+ *
+ * #### Undefined Behavior
+ * Searching a range which is not sorted in ascending order.
+ *
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function numberCmp(a: number, b: number): number {
+ *   return a - b;
+ * }
+ *
+ * let data = [0, 3, 4, 7, 7, 9];
+ * lowerArrayBound(data, 0, numberCmp);   // 0
+ * lowerArrayBound(data, 6, numberCmp);   // 3
+ * lowerArrayBound(data, 7, numberCmp);   // 3
+ * lowerArrayBound(data, -1, numberCmp);  // 0
+ * lowerArrayBound(data, 10, numberCmp);  // 6
+ * ```
+ */
+export declare function lowerArrayBound<T, U>(array: ArrayLike<T>, value: U, fn: (element: T, value: U) => number, start?: number, stop?: number): number;
+/**
+ * Find the index of the first element which compares `>` than a value.
+ *
+ * @param array - The sorted array-like object to search.
+ *
+ * @param value - The value to locate in the array.
+ *
+ * @param fn - The 3-way comparison function to apply to the values.
+ *   It should return `< 0` if an element is less than a value, `0` if
+ *   an element is equal to a value, or `> 0` if an element is greater
+ *   than a value.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The index of the first element which compares `>` than the
+ *   value, or `length` if there is no such element. If the computed
+ *   index for `stop` is less than `start`, then the computed index
+ *   for `start` is returned.
+ *
+ * #### Notes
+ * The array must already be sorted in ascending order according to
+ * the comparison function.
+ *
+ * #### Complexity
+ * Logarithmic.
+ *
+ * #### Undefined Behavior
+ * Searching a range which is not sorted in ascending order.
+ *
+ * A `start` or `stop` which is non-integral.
+ *
+ * Modifying the length of the array while searching.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function numberCmp(a: number, b: number): number {
+ *   return a - b;
+ * }
+ *
+ * let data = [0, 3, 4, 7, 7, 9];
+ * upperArrayBound(data, 0, numberCmp);   // 1
+ * upperArrayBound(data, 6, numberCmp);   // 3
+ * upperArrayBound(data, 7, numberCmp);   // 5
+ * upperArrayBound(data, -1, numberCmp);  // 0
+ * upperArrayBound(data, 10, numberCmp);  // 6
+ * ```
+ */
+export declare function upperArrayBound<T, U>(array: ArrayLike<T>, value: U, fn: (element: T, value: U) => number, start?: number, stop?: number): number;
+/**
+ * Remove all occurrences of values which match a predicate.
+ *
+ * @param array - The array of interest.
+ *
+ * @param fn - The predicate function to apply to the values.
+ *
+ * @param start - The index of the first element in the range to be
+ *   searched, inclusive. The default value is `0`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @param stop - The index of the last element in the range to be
+ *   searched, inclusive. The default value is `-1`. Negative values
+ *   are taken as an offset from the end of the array.
+ *
+ * @returns The number of elements removed from the array.
+ *
+ * #### Notes
+ * If `stop < start` the search will conceptually wrap at the end of
+ * the array, however the array will be traversed front-to-back.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * function isEven(value: number): boolean {
+ *   return value % 2 === 0;
+ * }
+ *
+ * function isNegative(value: number): boolean {
+ *   return value < 0;
+ * }
+ *
+ * let data = [0, 12, -13, -9, 23, 39, 14, -15, 12, 75];
+ * removeAllWhereFromArray(data, isEven);            // 4
+ * removeAllWhereFromArray(data, isNegative, 0, 3);  // 2
+ * ```
+ */
+export declare function removeAllWhereFromArray<T>(array: T[], fn: (value: T, index: number) => boolean, start?: number, stop?: number): number;
+//# sourceMappingURL=array.d.ts.map

package/es/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../src/array.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,EACR,KAAK,SAAI,EACT,IAAI,SAAK,GACR,MAAM,CA8BR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EACxC,KAAK,SAAI,EACT,IAAI,SAAK,GACR,MAAM,CA8BR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EACxC,KAAK,SAAK,EACV,IAAI,SAAI,GACP,MAAM,CA+BR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EACxC,KAAK,SAAI,EACT,IAAI,SAAK,GACR,CAAC,GAAG,SAAS,CAGf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EACxC,KAAK,SAAK,EACV,IAAI,SAAI,GACP,CAAC,GAAG,SAAS,CAGf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,EACR,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,EACpC,KAAK,SAAI,EACT,IAAI,SAAK,GACR,MAAM,CA8BR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,CAAC,EACR,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,MAAM,EACpC,KAAK,SAAI,EACT,IAAI,SAAK,GACR,MAAM,CA8BR;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,KAAK,EAAE,CAAC,EAAE,EACV,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,EACxC,KAAK,SAAI,EACT,IAAI,SAAK,GACR,MAAM,CAmCR"}

package/es/display-wrapper.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export declare const DisplayWrapComponent: React.FC<{
+    children: any;
+    mode: boolean | undefined;
+}>;
+//# sourceMappingURL=display-wrapper.d.ts.map

package/es/display-wrapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-wrapper.d.ts","sourceRoot":"","sources":["../src/display-wrapper.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAC1C,QAAQ,EAAE,GAAG,CAAC;IACd,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;CAC3B,CAKA,CAAC"}

package/es/index.d.ts

@@ -0,0 +1,11 @@
+export * from './array.js';
+export * from './iter.js';
+export * from './json.js';
+export * from './utils.js';
+export * from './sanitizer.js';
+export * from './url.js';
+export * from './path.js';
+export * from './polling/index.js';
+export * from './display-wrapper.js';
+export * from './protocol/index.js';
+//# sourceMappingURL=index.d.ts.map

package/es/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC"}

package/es/iter.d.ts

@@ -0,0 +1,147 @@
+/**
+ * An object which can produce an iterator over its values.
+ */
+export interface IIterable<T> {
+    /**
+     * Get an iterator over the object's values.
+     *
+     * @returns An iterator which yields the object's values.
+     *
+     * #### Notes
+     * Depending on the iterable, the returned iterator may or may not be
+     * a new object. A collection or other container-like object should
+     * typically return a new iterator, while an iterator itself should
+     * normally return `this`.
+     */
+    iter: () => IIterator<T>;
+}
+/**
+ * An object which traverses a collection of values.
+ *
+ * #### Notes
+ * An `IIterator` is itself an `IIterable`. Most implementations of
+ * `IIterator` should simply return `this` from the `iter()` method.
+ */
+export interface IIterator<T> extends IIterable<T> {
+    /**
+     * Create an independent clone of the iterator.
+     *
+     * @returns A new independent clone of the iterator.
+     *
+     * #### Notes
+     * The cloned iterator can be consumed independently of the current
+     * iterator. In essence, it is a copy of the iterator value stream
+     * which starts at the current location.
+     *
+     * This can be useful for lookahead and stream duplication.
+     */
+    clone: () => IIterator<T>;
+    /**
+     * Get the next value from the iterator.
+     *
+     * @returns The next value from the iterator, or `undefined`.
+     *
+     * #### Notes
+     * The `undefined` value is used to signal the end of iteration and
+     * should therefore not be used as a value in a collection.
+     *
+     * The use of the `undefined` sentinel is an explicit design choice
+     * which favors performance over purity. The ES6 iterator design of
+     * returning a `{ value, done }` pair is suboptimal, as it requires
+     * an object allocation on each iteration; and an `isDone()` method
+     * would increase implementation and runtime complexity.
+     */
+    next: () => T | undefined;
+}
+/**
+ * A type alias for an iterable or builtin array-like object.
+ */
+export type IterableOrArrayLike<T> = IIterable<T> | ArrayLike<T>;
+/**
+ * An iterator for an array-like object.
+ *
+ * #### Notes
+ * This iterator can be used for any builtin JS array-like object.
+ */
+export declare class ArrayIterator<T> implements IIterator<T> {
+    /**
+     * Construct a new array iterator.
+     *
+     * @param source - The array-like object of interest.
+     */
+    constructor(source: ArrayLike<T>);
+    /**
+     * Get an iterator over the object's values.
+     *
+     * @returns An iterator which yields the object's values.
+     */
+    iter(): IIterator<T>;
+    /**
+     * Create an independent clone of the iterator.
+     *
+     * @returns A new independent clone of the iterator.
+     */
+    clone(): IIterator<T>;
+    /**
+     * Get the next value from the iterator.
+     *
+     * @returns The next value from the iterator, or `undefined`.
+     */
+    next(): T | undefined;
+    private _index;
+    private _source;
+}
+/**
+ * Create an iterator for an iterable object.
+ *
+ * @param object - The iterable or array-like object of interest.
+ *
+ * @returns A new iterator for the given object.
+ *
+ * #### Notes
+ * This function allows iteration algorithms to operate on user-defined
+ * iterable types and builtin array-like objects in a uniform fashion.
+ */
+export declare function iter<T>(object: IterableOrArrayLike<T>): IIterator<T>;
+/**
+ * Invoke a function for each value in an iterable.
+ *
+ * @param object - The iterable or array-like object of interest.
+ *
+ * @param fn - The callback function to invoke for each value.
+ *
+ * #### Notes
+ * Iteration can be terminated early by returning `false` from the
+ * callback function.
+ *
+ * #### Complexity
+ * Linear.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * let data = [5, 7, 0, -2, 9];
+ *
+ * each(data, value => { console.log(value); });
+ * ```
+ */
+export declare function each<T>(object: IterableOrArrayLike<T>, fn: (value: T, index: number) => boolean | void): void;
+/**
+ * Create an array from an iterable of values.
+ *
+ * @param object - The iterable or array-like object of interest.
+ *
+ * @returns A new array of values from the given object.
+ *
+ * #### Example
+ * ```typescript
+ *
+ * let data = [1, 2, 3, 4, 5, 6];
+ *
+ * let stream = iter(data);
+ *
+ * toArray(stream);  // [1, 2, 3, 4, 5, 6];
+ * ```
+ */
+export declare function toArray<T>(object: IterableOrArrayLike<T>): T[];
+//# sourceMappingURL=iter.d.ts.map

package/es/iter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iter.d.ts","sourceRoot":"","sources":["../src/iter.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B;;;;;;;;;;OAUG;IACH,IAAI,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC;IAChD;;;;;;;;;;;OAWG;IACH,KAAK,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,CAAC;IAE1B;;;;;;;;;;;;;;OAcG;IACH,IAAI,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC;AAEjE;;;;;GAKG;AACH,qBAAa,aAAa,CAAC,CAAC,CAAE,YAAW,SAAS,CAAC,CAAC,CAAC;IACnD;;;;OAIG;gBACS,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IAIhC;;;;OAIG;IACH,IAAI,IAAI,SAAS,CAAC,CAAC,CAAC;IAIpB;;;;OAIG;IACH,KAAK,IAAI,SAAS,CAAC,CAAC,CAAC;IAMrB;;;;OAIG;IACH,IAAI,IAAI,CAAC,GAAG,SAAS;IAOrB,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,OAAO,CAAe;CAC/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAQpE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAC9B,EAAE,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,IAAI,GAC9C,IAAI,CASN;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,CAS9D"}

package/es/json.d.ts

@@ -0,0 +1,126 @@
+/**
+ * A type alias for a JSON primitive.
+ */
+export type JSONPrimitive = boolean | number | string | null;
+/**
+ * A type alias for a JSON value.
+ */
+export type JSONValue = JSONPrimitive | {
+    [key: string]: JSONValue;
+} | JSONValue[];
+/**
+ * A type definition for a JSON object.
+ */
+export type JSONObject = Record<string, JSONValue>;
+/**
+ * A type definition for a JSON array.
+ */
+export type JSONArray = JSONValue[];
+/**
+ * A type definition for a readonly JSON object.
+ */
+export type ReadonlyJSONObject = Readonly<Record<string, ReadonlyJSONValue>>;
+/**
+ * A type definition for a readonly JSON array.
+ */
+export type ReadonlyJSONArray = readonly ReadonlyJSONValue[];
+/**
+ * A type alias for a readonly JSON value.
+ */
+export type ReadonlyJSONValue = JSONPrimitive | Readonly<{
+    [key: string]: ReadonlyJSONValue;
+}> | readonly ReadonlyJSONValue[];
+/**
+ * A type alias for a partial JSON value.
+ *
+ * Note: Partial here means that JSON object attributes can be `undefined`.
+ */
+export type PartialJSONValue = JSONPrimitive | Partial<{
+    [key: string]: PartialJSONValue;
+}> | PartialJSONValue[];
+/**
+ * A type definition for a partial JSON array.
+ *
+ * Note: Partial here means that JSON object attributes can be `undefined`.
+ */
+export type PartialJSONArray = PartialJSONValue[];
+/**
+ * A type definition for a partial JSON object.
+ *
+ * Note: Partial here means that the JSON object attributes can be `undefined`.
+ */
+export type PartialJSONObject = Record<string, PartialJSONValue | undefined>;
+/**
+ * A type definition for a readonly partial JSON object.
+ *
+ * Note: Partial here means that JSON object attributes can be `undefined`.
+ */
+export type ReadonlyPartialJSONObject = Readonly<Record<string, ReadonlyPartialJSONValue | undefined>>;
+/**
+ * A type definition for a readonly partial JSON array.
+ *
+ * Note: Partial here means that JSON object attributes can be `undefined`.
+ */
+export type ReadonlyPartialJSONArray = readonly ReadonlyPartialJSONValue[];
+/**
+ * A type alias for a readonly partial JSON value.
+ *
+ * Note: Partial here means that JSON object attributes can be `undefined`.
+ */
+export type ReadonlyPartialJSONValue = JSONPrimitive | {
+    readonly [key: string]: ReadonlyPartialJSONValue | undefined;
+} | readonly ReadonlyPartialJSONValue[];
+/**
+ * A shared frozen empty JSONObject
+ */
+export declare const emptyObject: Readonly<Record<string, ReadonlyJSONValue>>;
+/**
+ * A shared frozen empty JSONArray
+ */
+export declare const emptyArray: ReadonlyJSONArray;
+/**
+ * Test whether a JSON value is a primitive.
+ *
+ * @param value - The JSON value of interest.
+ *
+ * @returns `true` if the value is a primitive,`false` otherwise.
+ */
+export declare function isPrimitive(value: ReadonlyPartialJSONValue): value is JSONPrimitive;
+/**
+ * Test whether a JSON value is an array.
+ *
+ * @param value - The JSON value of interest.
+ *
+ * @returns `true` if the value is a an array, `false` otherwise.
+ */
+export declare function isArray(value: JSONValue): value is JSONArray;
+export declare function isArray(value: PartialJSONValue): value is PartialJSONArray;
+export declare function isArray(value: ReadonlyPartialJSONValue): value is ReadonlyPartialJSONArray;
+/**
+ * Test whether a JSON value is an object.
+ *
+ * @param value - The JSON value of interest.
+ *
+ * @returns `true` if the value is a an object, `false` otherwise.
+ */
+export declare function isObject(value: JSONValue): value is JSONObject;
+export declare function isObject(value: PartialJSONValue): value is PartialJSONObject;
+/**
+ * Compare two JSON values for deep equality.
+ *
+ * @param first - The first JSON value of interest.
+ *
+ * @param second - The second JSON value of interest.
+ *
+ * @returns `true` if the values are equivalent, `false` otherwise.
+ */
+export declare function deepEqual(first: ReadonlyPartialJSONValue, second: ReadonlyPartialJSONValue): boolean;
+/**
+ * Create a deep copy of a JSON value.
+ *
+ * @param value - The JSON value to copy.
+ *
+ * @returns A deep copy of the given JSON value.
+ */
+export declare function deepCopy<T extends ReadonlyPartialJSONValue>(value: T): T;
+//# sourceMappingURL=json.d.ts.map

package/es/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;AAE7D;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,GAAG,SAAS,EAAE,CAAC;AAEnF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,SAAS,EAAE,CAAC;AAEpC;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,SAAS,iBAAiB,EAAE,CAAC;AAE7D;;GAEG;AACH,MAAM,MAAM,iBAAiB,GACzB,aAAa,GACb,QAAQ,CAAC;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,iBAAiB,CAAA;CAAE,CAAC,GAC9C,SAAS,iBAAiB,EAAE,CAAC;AAEjC;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GACxB,aAAa,GACb,OAAO,CAAC;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAAA;CAAE,CAAC,GAC5C,gBAAgB,EAAE,CAAC;AAEvB;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,EAAE,CAAC;AAElD;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,GAAG,SAAS,CAAC,CAAC;AAE7E;;;;GAIG;AACH,MAAM,MAAM,yBAAyB,GAAG,QAAQ,CAC9C,MAAM,CAAC,MAAM,EAAE,wBAAwB,GAAG,SAAS,CAAC,CACrD,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG,SAAS,wBAAwB,EAAE,CAAC;AAE3E;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAChC,aAAa,GACb;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,wBAAwB,GAAG,SAAS,CAAA;CAAE,GAChE,SAAS,wBAAwB,EAAE,CAAC;AAExC;;GAEG;AACH,eAAO,MAAM,WAAW,6CAA0C,CAAC;AAEnE;;GAEG;AACH,eAAO,MAAM,UAAU,mBAAyC,CAAC;AAEjE;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,wBAAwB,GAAG,KAAK,IAAI,aAAa,CAOnF;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,SAAS,GAAG,KAAK,IAAI,SAAS,CAAC;AAE9D,wBAAgB,OAAO,CAAC,KAAK,EAAE,gBAAgB,GAAG,KAAK,IAAI,gBAAgB,CAAC;AAC5E,wBAAgB,OAAO,CACrB,KAAK,EAAE,wBAAwB,GAC9B,KAAK,IAAI,wBAAwB,CAAC;AAKrC;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,KAAK,IAAI,UAAU,CAAC;AAEhE,wBAAgB,QAAQ,CAAC,KAAK,EAAE,gBAAgB,GAAG,KAAK,IAAI,iBAAiB,CAAC;AAM9E;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,wBAAwB,EAC/B,MAAM,EAAE,wBAAwB,GAC/B,OAAO,CAiCT;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,wBAAwB,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAaxE"}