@clary-so/measure 0.4.6 → 0.4.7

package/node_modules/ansi-escapes/node_modules/type-fest/source/typed-array.d.ts

@@ -0,0 +1,15 @@
+/**
+Matches any [typed array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray), like `Uint8Array` or `Float64Array`.
+*/
+export type TypedArray =
+	| Int8Array
+	| Uint8Array
+	| Uint8ClampedArray
+	| Int16Array
+	| Uint16Array
+	| Int32Array
+	| Uint32Array
+	| Float32Array
+	| Float64Array
+	| BigInt64Array
+	| BigUint64Array;

package/node_modules/ansi-escapes/node_modules/type-fest/source/union-to-intersection.d.ts

@@ -0,0 +1,58 @@
+/**
+Convert a union type to an intersection type using [distributive conditional types](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+
+Inspired by [this Stack Overflow answer](https://stackoverflow.com/a/50375286/2172153).
+
+@example
+```
+import {UnionToIntersection} from 'type-fest';
+
+type Union = {the(): void} | {great(arg: string): void} | {escape: boolean};
+
+type Intersection = UnionToIntersection<Union>;
+//=> {the(): void; great(arg: string): void; escape: boolean};
+```
+
+A more applicable example which could make its way into your library code follows.
+
+@example
+```
+import {UnionToIntersection} from 'type-fest';
+
+class CommandOne {
+	commands: {
+		a1: () => undefined,
+		b1: () => undefined,
+	}
+}
+
+class CommandTwo {
+	commands: {
+		a2: (argA: string) => undefined,
+		b2: (argB: string) => undefined,
+	}
+}
+
+const union = [new CommandOne(), new CommandTwo()].map(instance => instance.commands);
+type Union = typeof union;
+//=> {a1(): void; b1(): void} | {a2(argA: string): void; b2(argB: string): void}
+
+type Intersection = UnionToIntersection<Union>;
+//=> {a1(): void; b1(): void; a2(argA: string): void; b2(argB: string): void}
+```
+*/
+export type UnionToIntersection<Union> = (
+	// `extends unknown` is always going to be the case and is used to convert the
+	// `Union` into a [distributive conditional
+	// type](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types).
+	Union extends unknown
+		// The union type is used as the only argument to a function since the union
+		// of function arguments is an intersection.
+		? (distributedUnion: Union) => void
+		// This won't happen.
+		: never
+		// Infer the `Intersection` type since TypeScript represents the positional
+		// arguments of unions of functions as an intersection of the union.
+	) extends ((mergedIntersection: infer Intersection) => void)
+		? Intersection
+		: never;

package/node_modules/ansi-escapes/node_modules/type-fest/source/utilities.d.ts

@@ -0,0 +1,5 @@
+export type UpperCaseCharacters = 'A' | 'B' | 'C' | 'D' | 'E' | 'F' | 'G' | 'H' | 'I' | 'J' | 'K' | 'L' | 'M' | 'N' | 'O' | 'P' | 'Q' | 'R' | 'S' | 'T' | 'U' | 'V' | 'W' | 'X' | 'Y' | 'Z';
+
+export type WordSeparators = '-' | '_' | ' ';
+
+export type StringDigit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';

package/node_modules/ansi-escapes/node_modules/type-fest/source/value-of.d.ts

@@ -0,0 +1,40 @@
+/**
+Create a union of the given object's values, and optionally specify which keys to get the values from.
+
+Please upvote [this issue](https://github.com/microsoft/TypeScript/issues/31438) if you want to have this type as a built-in in TypeScript.
+
+@example
+```
+// data.json
+{
+	'foo': 1,
+	'bar': 2,
+	'biz': 3
+}
+
+// main.ts
+import {ValueOf} from 'type-fest';
+import data = require('./data.json');
+
+export function getData(name: string): ValueOf<typeof data> {
+	return data[name];
+}
+
+export function onlyBar(name: string): ValueOf<typeof data, 'bar'> {
+	return data[name];
+}
+
+// file.ts
+import {getData, onlyBar} from './main';
+
+getData('foo');
+//=> 1
+
+onlyBar('foo');
+//=> TypeError ...
+
+onlyBar('bar');
+//=> 2
+```
+*/
+export type ValueOf<ObjectType, ValueType extends keyof ObjectType = keyof ObjectType> = ObjectType[ValueType];

package/node_modules/ansi-escapes/node_modules/type-fest/ts41/camel-case.d.ts

@@ -0,0 +1,64 @@
+import {WordSeparators} from '../source/utilities';
+import {Split} from './utilities';
+
+/**
+Step by step takes the first item in an array literal, formats it and adds it to a string literal, and then recursively appends the remainder.
+
+Only to be used by `CamelCaseStringArray<>`.
+
+@see CamelCaseStringArray
+*/
+type InnerCamelCaseStringArray<Parts extends any[], PreviousPart> =
+	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
+		? FirstPart extends undefined
+			? ''
+			: FirstPart extends ''
+					? InnerCamelCaseStringArray<RemainingParts, PreviousPart>
+					: `${PreviousPart extends '' ? FirstPart : Capitalize<FirstPart>}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`
+		: '';
+
+/**
+Starts fusing the output of `Split<>`, an array literal of strings, into a camel-cased string literal.
+
+It's separate from `InnerCamelCaseStringArray<>` to keep a clean API outwards to the rest of the code.
+
+@see Split
+*/
+type CamelCaseStringArray<Parts extends string[]> =
+	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
+		? Uncapitalize<`${FirstPart}${InnerCamelCaseStringArray<RemainingParts, FirstPart>}`>
+		: never;
+
+/**
+Convert a string literal to camel-case.
+
+This can be useful when, for example, converting some kebab-cased command-line flags or a snake-cased database result.
+
+@example
+```
+import {CamelCase} from 'type-fest';
+
+// Simple
+
+const someVariable: CamelCase<'foo-bar'> = 'fooBar';
+
+// Advanced
+
+type CamelCasedProps<T> = {
+	[K in keyof T as CamelCase<K>]: T[K]
+};
+
+interface RawOptions {
+	'dry-run': boolean;
+	'full_family_name': string;
+	foo: number;
+}
+
+const dbResult: CamelCasedProps<ModelProps> = {
+	dryRun: true,
+	fullFamilyName: 'bar.js',
+	foo: 123
+};
+```
+*/
+export type CamelCase<K> = K extends string ? CamelCaseStringArray<Split<K, WordSeparators>> : K;

package/node_modules/ansi-escapes/node_modules/type-fest/ts41/delimiter-case.d.ts

@@ -0,0 +1,85 @@
+import {UpperCaseCharacters, WordSeparators} from '../source/utilities';
+
+/**
+Unlike a simpler split, this one includes the delimiter splitted on in the resulting array literal. This is to enable splitting on, for example, upper-case characters.
+*/
+export type SplitIncludingDelimiters<Source extends string, Delimiter extends string> =
+	Source extends '' ? [] :
+	Source extends `${infer FirstPart}${Delimiter}${infer SecondPart}` ?
+	(
+		Source extends `${FirstPart}${infer UsedDelimiter}${SecondPart}`
+			? UsedDelimiter extends Delimiter
+				? Source extends `${infer FirstPart}${UsedDelimiter}${infer SecondPart}`
+					? [...SplitIncludingDelimiters<FirstPart, Delimiter>, UsedDelimiter, ...SplitIncludingDelimiters<SecondPart, Delimiter>]
+					: never
+				: never
+			: never
+	) :
+	[Source];
+
+/**
+Format a specific part of the splitted string literal that `StringArrayToDelimiterCase<>` fuses together, ensuring desired casing.
+
+@see StringArrayToDelimiterCase
+*/
+type StringPartToDelimiterCase<StringPart extends string, UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
+	StringPart extends UsedWordSeparators ? Delimiter :
+	StringPart extends UsedUpperCaseCharacters ? `${Delimiter}${Lowercase<StringPart>}` :
+	StringPart;
+
+/**
+Takes the result of a splitted string literal and recursively concatenates it together into the desired casing.
+
+It receives `UsedWordSeparators` and `UsedUpperCaseCharacters` as input to ensure it's fully encapsulated.
+
+@see SplitIncludingDelimiters
+*/
+type StringArrayToDelimiterCase<Parts extends any[], UsedWordSeparators extends string, UsedUpperCaseCharacters extends string, Delimiter extends string> =
+	Parts extends [`${infer FirstPart}`, ...infer RemainingParts]
+		? `${StringPartToDelimiterCase<FirstPart, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}${StringArrayToDelimiterCase<RemainingParts, UsedWordSeparators, UsedUpperCaseCharacters, Delimiter>}`
+		: '';
+
+/**
+Convert a string literal to a custom string delimiter casing.
+
+This can be useful when, for example, converting a camel-cased object property to an oddly cased one.
+
+@see KebabCase
+@see SnakeCase
+
+@example
+```
+import {DelimiterCase} from 'type-fest';
+
+// Simple
+
+const someVariable: DelimiterCase<'fooBar', '#'> = 'foo#bar';
+
+// Advanced
+
+type OddlyCasedProps<T> = {
+	[K in keyof T as DelimiterCase<K, '#'>]: T[K]
+};
+
+interface SomeOptions {
+	dryRun: boolean;
+	includeFile: string;
+	foo: number;
+}
+
+const rawCliOptions: OddlyCasedProps<SomeOptions> = {
+	'dry#run': true,
+	'include#file': 'bar.js',
+	foo: 123
+};
+```
+*/
+
+export type DelimiterCase<Value, Delimiter extends string> = Value extends string
+	? StringArrayToDelimiterCase<
+		SplitIncludingDelimiters<Value, WordSeparators | UpperCaseCharacters>,
+		WordSeparators,
+		UpperCaseCharacters,
+		Delimiter
+	>
+	: Value;

package/node_modules/ansi-escapes/node_modules/type-fest/ts41/get.d.ts

@@ -0,0 +1,131 @@
+import {Split} from './utilities';
+import {StringDigit} from '../source/utilities';
+
+/**
+Like the `Get` type but receives an array of strings as a path parameter.
+*/
+type GetWithPath<BaseType, Keys extends readonly string[]> =
+	Keys extends []
+	? BaseType
+	: Keys extends [infer Head, ...infer Tail]
+	? GetWithPath<PropertyOf<BaseType, Extract<Head, string>>, Extract<Tail, string[]>>
+	: never;
+
+/**
+Splits a dot-prop style path into a tuple comprised of the properties in the path. Handles square-bracket notation.
+
+@example
+```
+ToPath<'foo.bar.baz'>
+//=> ['foo', 'bar', 'baz']
+
+ToPath<'foo[0].bar.baz'>
+//=> ['foo', '0', 'bar', 'baz']
+```
+*/
+type ToPath<S extends string> = Split<FixPathSquareBrackets<S>, '.'>;
+
+/**
+Replaces square-bracketed dot notation with dots, for example, `foo[0].bar` -> `foo.0.bar`.
+*/
+type FixPathSquareBrackets<Path extends string> =
+	Path extends `${infer Head}[${infer Middle}]${infer Tail}`
+	? `${Head}.${Middle}${FixPathSquareBrackets<Tail>}`
+	: Path;
+
+/**
+Returns true if `LongString` is made up out of `Substring` repeated 0 or more times.
+
+@example
+```
+ConsistsOnlyOf<'aaa', 'a'> //=> true
+ConsistsOnlyOf<'ababab', 'ab'> //=> true
+ConsistsOnlyOf<'aBa', 'a'> //=> false
+ConsistsOnlyOf<'', 'a'> //=> true
+```
+*/
+type ConsistsOnlyOf<LongString extends string, Substring extends string> =
+	LongString extends ''
+	? true
+	: LongString extends `${Substring}${infer Tail}`
+	? ConsistsOnlyOf<Tail, Substring>
+  : false;
+
+/**
+Convert a type which may have number keys to one with string keys, making it possible to index using strings retrieved from template types.
+
+@example
+```
+type WithNumbers = {foo: string; 0: boolean};
+type WithStrings = WithStringKeys<WithNumbers>;
+
+type WithNumbersKeys = keyof WithNumbers;
+//=> 'foo' | 0
+type WithStringsKeys = keyof WithStrings;
+//=> 'foo' | '0'
+```
+*/
+type WithStringKeys<BaseType extends Record<string | number, any>> = {
+	[Key in `${Extract<keyof BaseType, string | number>}`]: BaseType[Key]
+};
+
+/**
+Get a property of an object or array. Works when indexing arrays using number-literal-strings, for example, `PropertyOf<number[], '0'> = number`, and when indexing objects with number keys.
+
+Note:
+- Returns `unknown` if `Key` is not a property of `BaseType`, since TypeScript uses structural typing, and it cannot be guaranteed that extra properties unknown to the type system will exist at runtime.
+- Returns `undefined` from nullish values, to match the behaviour of most deep-key libraries like `lodash`, `dot-prop`, etc.
+*/
+type PropertyOf<BaseType, Key extends string> =
+	BaseType extends null | undefined
+	? undefined
+	: Key extends keyof BaseType
+	? BaseType[Key]
+	: BaseType extends {
+		[n: number]: infer Item;
+		length: number; // Note: This is needed to avoid being too lax with records types using number keys like `{0: string; 1: boolean}`.
+	}
+	? (
+		ConsistsOnlyOf<Key, StringDigit> extends true
+		? Item
+		: unknown
+	)
+	: Key extends keyof WithStringKeys<BaseType>
+	? WithStringKeys<BaseType>[Key]
+	: unknown;
+
+// This works by first splitting the path based on `.` and `[...]` characters into a tuple of string keys. Then it recursively uses the head key to get the next property of the current object, until there are no keys left. Number keys extract the item type from arrays, or are converted to strings to extract types from tuples and dictionaries with number keys.
+/**
+Get a deeply-nested property from an object using a key path, like Lodash's `.get()` function.
+
+Use-case: Retrieve a property from deep inside an API response or some other complex object.
+
+@example
+```
+import {Get} from 'type-fest';
+import * as lodash from 'lodash';
+
+const get = <BaseType, Path extends string>(object: BaseType, path: Path): Get<BaseType, Path> =>
+	lodash.get(object, path);
+
+interface ApiResponse {
+	hits: {
+		hits: Array<{
+			_id: string
+			_source: {
+				name: Array<{
+					given: string[]
+					family: string
+				}>
+				birthDate: string
+			}
+		}>
+	}
+}
+
+const getName = (apiResponse: ApiResponse) =>
+	get(apiResponse, 'hits.hits[0]._source.name');
+	//=> Array<{given: string[]; family: string}>
+```
+*/
+export type Get<BaseType, Path extends string> = GetWithPath<BaseType, ToPath<Path>>;

package/node_modules/ansi-escapes/node_modules/type-fest/ts41/index.d.ts

@@ -0,0 +1,10 @@
+// These are all the basic types that's compatible with all supported TypeScript versions.
+export * from '../base';
+
+// These are special types that require at least TypeScript 4.1.
+export {CamelCase} from './camel-case';
+export {KebabCase} from './kebab-case';
+export {PascalCase} from './pascal-case';
+export {SnakeCase} from './snake-case';
+export {DelimiterCase} from './delimiter-case';
+export {Get} from './get';

package/node_modules/ansi-escapes/node_modules/type-fest/ts41/kebab-case.d.ts

@@ -0,0 +1,36 @@
+import {DelimiterCase} from './delimiter-case';
+
+/**
+Convert a string literal to kebab-case.
+
+This can be useful when, for example, converting a camel-cased object property to a kebab-cased CSS class name or a command-line flag.
+
+@example
+```
+import {KebabCase} from 'type-fest';
+
+// Simple
+
+const someVariable: KebabCase<'fooBar'> = 'foo-bar';
+
+// Advanced
+
+type KebabCasedProps<T> = {
+	[K in keyof T as KebabCase<K>]: T[K]
+};
+
+interface CliOptions {
+	dryRun: boolean;
+	includeFile: string;
+	foo: number;
+}
+
+const rawCliOptions: KebabCasedProps<CliOptions> = {
+	'dry-run': true,
+	'include-file': 'bar.js',
+	foo: 123
+};
+```
+*/
+
+export type KebabCase<Value> = DelimiterCase<Value, '-'>;

package/node_modules/ansi-escapes/node_modules/type-fest/ts41/pascal-case.d.ts

@@ -0,0 +1,36 @@
+import {CamelCase} from './camel-case';
+
+/**
+Converts a string literal to pascal-case.
+
+@example
+```
+import {PascalCase} from 'type-fest';
+
+// Simple
+
+const someVariable: PascalCase<'foo-bar'> = 'FooBar';
+
+// Advanced
+
+type PascalCaseProps<T> = {
+	[K in keyof T as PascalCase<K>]: T[K]
+};
+
+interface RawOptions {
+	'dry-run': boolean;
+	'full_family_name': string;
+	foo: number;
+}
+
+const dbResult: CamelCasedProps<ModelProps> = {
+	DryRun: true,
+	FullFamilyName: 'bar.js',
+	Foo: 123
+};
+```
+*/
+
+export type PascalCase<Value> = CamelCase<Value> extends string
+	? Capitalize<CamelCase<Value>>
+	: CamelCase<Value>;

package/node_modules/ansi-escapes/node_modules/type-fest/ts41/snake-case.d.ts

@@ -0,0 +1,35 @@
+import {DelimiterCase} from './delimiter-case';
+
+/**
+Convert a string literal to snake-case.
+
+This can be useful when, for example, converting a camel-cased object property to a snake-cased SQL column name.
+
+@example
+```
+import {SnakeCase} from 'type-fest';
+
+// Simple
+
+const someVariable: SnakeCase<'fooBar'> = 'foo_bar';
+
+// Advanced
+
+type SnakeCasedProps<T> = {
+	[K in keyof T as SnakeCase<K>]: T[K]
+};
+
+interface ModelProps {
+	isHappy: boolean;
+	fullFamilyName: string;
+	foo: number;
+}
+
+const dbResult: SnakeCasedProps<ModelProps> = {
+	'is_happy': true,
+	'full_family_name': 'Carla Smith',
+	foo: 123
+};
+```
+*/
+export type SnakeCase<Value> = DelimiterCase<Value, '_'>;

package/node_modules/ansi-escapes/node_modules/type-fest/ts41/utilities.d.ts

@@ -0,0 +1,8 @@
+/**
+Recursively split a string literal into two parts on the first occurence of the given string, returning an array literal of all the separate parts.
+*/
+export type Split<S extends string, D extends string> =
+	string extends S ? string[] :
+	S extends '' ? [] :
+	S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] :
+	[S];

package/node_modules/ansi-escapes/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "ansi-escapes",
+	"version": "4.3.2",
+	"description": "ANSI escape codes for manipulating the terminal",
+	"license": "MIT",
+	"repository": "sindresorhus/ansi-escapes",
+	"funding": "https://github.com/sponsors/sindresorhus",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "https://sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"ansi",
+		"terminal",
+		"console",
+		"cli",
+		"string",
+		"tty",
+		"escape",
+		"escapes",
+		"formatting",
+		"shell",
+		"xterm",
+		"log",
+		"logging",
+		"command-line",
+		"text",
+		"vt100",
+		"sequence",
+		"control",
+		"code",
+		"codes",
+		"cursor",
+		"iterm",
+		"iterm2"
+	],
+	"dependencies": {
+		"type-fest": "^0.21.3"
+	},
+	"devDependencies": {
+		"@types/node": "^13.7.7",
+		"ava": "^2.1.0",
+		"tsd": "^0.14.0",
+		"xo": "^0.25.3"
+	}
+}