diff --git a/tools/ui/node_modules/expect-type/dist/branding.d.ts b/tools/ui/node_modules/expect-type/dist/branding.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..b59cccd15984ad17df7f63722e47ecf3ade78817 --- /dev/null +++ b/tools/ui/node_modules/expect-type/dist/branding.d.ts @@ -0,0 +1,61 @@ +import type { ConstructorOverloadParameters, NumOverloads, OverloadsInfoUnion } from './overloads'; +import type { IsNever, IsAny, IsUnknown, ReadonlyKeys, RequiredKeys, OptionalKeys, MutuallyExtends, UnionToTuple } from './utils'; +/** + * Represents a deeply branded type. + * + * Recursively walk a type and replace it with a branded type related to the + * original. This is useful for equality-checking stricter than + * `A extends B ? B extends A ? true : false : false`, because it detects the + * difference between a few edge-case types that vanilla TypeScript + * doesn't by default: + * - `any` vs `unknown` + * - `{ readonly a: string }` vs `{ a: string }` + * - `{ a?: string }` vs `{ a: string | undefined }` + * + * __Note__: not very performant for complex types - this should only be used + * when you know you need it. If doing an equality check, it's almost always + * better to use {@linkcode StrictEqualUsingTSInternalIdenticalToOperator}. + */ +export type DeepBrand = IsNever extends true ? { + type: 'never'; +} : IsAny extends true ? { + type: 'any'; +} : IsUnknown extends true ? { + type: 'unknown'; +} : T extends string | number | boolean | symbol | bigint | null | undefined | void ? { + type: 'primitive'; + value: T; +} : T extends new (...args: any[]) => any ? { + type: 'constructor'; + params: ConstructorOverloadParameters; + instance: DeepBrand any>>>; +} : T extends (...args: infer P) => infer R ? NumOverloads extends 1 ? { + type: 'function'; + params: DeepBrand

; + return: DeepBrand; + this: DeepBrand>; + props: DeepBrand>; +} : UnionToTuple> extends infer OverloadsTuple ? { + type: 'overloads'; + overloads: { + [K in keyof OverloadsTuple]: DeepBrand; + }; +} : never : T extends any[] ? { + type: 'array'; + items: { + [K in keyof T]: T[K]; + }; +} : { + type: 'object'; + properties: { + [K in keyof T]: DeepBrand; + }; + readonly: ReadonlyKeys; + required: RequiredKeys; + optional: OptionalKeys; + constructorParams: DeepBrand>; +}; +/** + * Checks if two types are strictly equal using branding. + */ +export type StrictEqualUsingBranding = MutuallyExtends, DeepBrand>; diff --git a/tools/ui/node_modules/expect-type/dist/branding.js b/tools/ui/node_modules/expect-type/dist/branding.js new file mode 100644 index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce --- /dev/null +++ b/tools/ui/node_modules/expect-type/dist/branding.js @@ -0,0 +1,2 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/tools/ui/node_modules/expect-type/dist/index.d.ts b/tools/ui/node_modules/expect-type/dist/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4098988f1a007125653df917aad8231925d63f8a --- /dev/null +++ b/tools/ui/node_modules/expect-type/dist/index.d.ts @@ -0,0 +1,897 @@ +import type { StrictEqualUsingBranding } from './branding'; +import type { ExpectAny, ExpectArray, ExpectBigInt, ExpectBoolean, ExpectFunction, ExpectNever, ExpectNull, ExpectNullable, ExpectNumber, ExpectObject, ExpectString, ExpectSymbol, ExpectUndefined, ExpectUnknown, ExpectVoid, MismatchInfo, Scolder } from './messages'; +import type { ConstructorOverloadParameters, OverloadParameters, OverloadReturnTypes, OverloadsNarrowedByParameters } from './overloads'; +import type { AValue, DeepPickMatchingProps, Extends, IsUnion, MismatchArgs, Not, StrictEqualUsingTSInternalIdenticalToOperator } from './utils'; +export * from './branding'; +export * from './messages'; +export * from './overloads'; +export * from './utils'; +/** + * Represents the positive assertion methods available for type checking in the + * {@linkcode expectTypeOf()} utility. + */ +export interface PositiveExpectTypeOf extends BaseExpectTypeOf { + /** + * Similar to jest's `expect(...).toMatchObject(...)` but for types. + * Deeply "picks" the properties of the actual type based on the expected type, then performs a strict check to make sure the types match `Expected`. + * + * **Note**: optional properties on the {@linkcode Expected | expected type} are not allowed to be missing on the {@linkcode Actual | actual type}. + * + * @example + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchObjectType<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toMatchObjectType<{ a: number; c?: number }>() + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toMatchObjectType: extends true ? 'toMatchObject does not support union types' : Not>> extends true ? 'toMatchObject only supports object types' : StrictEqualUsingTSInternalIdenticalToOperator, Expected> extends true ? unknown : MismatchInfo, Expected>>(...MISMATCH: MismatchArgs, Expected>, true>) => true; + /** + * Check if your type extends the expected type + * + * A less strict version of {@linkcode toEqualTypeOf | .toEqualTypeOf()} that allows for extra properties. + * This is roughly equivalent to an `extends` constraint in a function type argument. + * + * @example + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toExtend<{ a: number }>() + * + * expectTypeOf({ a: 1 }).not.toExtend<{ b: number }>() + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toExtend: extends true ? unknown : MismatchInfo>(...MISMATCH: MismatchArgs, true>) => true; + toEqualTypeOf: { + /** + * Uses TypeScript's internal technique to check for type "identicalness". + * + * It will check if the types are fully equal to each other. + * It will not fail if two objects have different values, but the same type. + * It will fail however if an object is missing a property. + * + * **_Unexpected failure_**? For a more permissive but less performant + * check that accommodates for equivalent intersection types, + * use {@linkcode branded | .branded.toEqualTypeOf()}. + * @see {@link https://github.com/mmkal/expect-type#why-is-my-assertion-failing | The documentation for details}. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toEqualTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 1 }) + * + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 2 }) + * ``` + * + * @param value - The value to compare against the expected type. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + extends true ? unknown : MismatchInfo>(value: Expected & AValue, // reason for `& AValue`: make sure this is only the selected overload when the end-user passes a value for an inferred typearg. The `Mismatch` type does match `AValue`. + ...MISMATCH: MismatchArgs, true>): true; + /** + * Uses TypeScript's internal technique to check for type "identicalness". + * + * It will check if the types are fully equal to each other. + * It will not fail if two objects have different values, but the same type. + * It will fail however if an object is missing a property. + * + * **_Unexpected failure_**? For a more permissive but less performant + * check that accommodates for equivalent intersection types, + * use {@linkcode branded | .branded.toEqualTypeOf()}. + * @see {@link https://github.com/mmkal/expect-type#why-is-my-assertion-failing | The documentation for details}. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toEqualTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 1 }) + * + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 2 }) + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + extends true ? unknown : MismatchInfo>(...MISMATCH: MismatchArgs, true>): true; + }; + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + */ + toMatchTypeOf: { + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + * + * A less strict version of {@linkcode toEqualTypeOf | .toEqualTypeOf()} + * that allows for extra properties. + * This is roughly equivalent to an `extends` constraint + * in a function type argument. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf({ a: 2 }) + * ``` + * + * @param value - The value to compare against the expected type. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + extends true ? unknown : MismatchInfo>(value: Expected & AValue, // reason for `& AValue`: make sure this is only the selected overload when the end-user passes a value for an inferred typearg. The `Mismatch` type does match `AValue`. + ...MISMATCH: MismatchArgs, true>): true; + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + * + * A less strict version of {@linkcode toEqualTypeOf | .toEqualTypeOf()} + * that allows for extra properties. + * This is roughly equivalent to an `extends` constraint + * in a function type argument. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf({ a: 2 }) + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + extends true ? unknown : MismatchInfo>(...MISMATCH: MismatchArgs, true>): true; + }; + /** + * Checks whether an object has a given property. + * + * @example + * check that properties exist + * ```ts + * const obj = { a: 1, b: '' } + * + * expectTypeOf(obj).toHaveProperty('a') + * + * expectTypeOf(obj).not.toHaveProperty('c') + * ``` + * + * @param key - The property key to check for. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toHaveProperty: (key: KeyType, ...MISMATCH: MismatchArgs, true>) => KeyType extends keyof Actual ? PositiveExpectTypeOf : true; + /** + * Inverts the result of the following assertions. + * + * @example + * ```ts + * expectTypeOf({ a: 1 }).not.toMatchTypeOf({ b: 1 }) + * ``` + */ + not: NegativeExpectTypeOf; + /** + * Intersection types can cause issues with + * {@linkcode toEqualTypeOf | .toEqualTypeOf()}: + * ```ts + * // ❌ The following line doesn't compile, even though the types are arguably the same. + * expectTypeOf<{ a: 1 } & { b: 2 }>().toEqualTypeOf<{ a: 1; b: 2 }>() + * ``` + * This helper works around this problem by using + * a more permissive but less performant check. + * + * __Note__: This comes at a performance cost, and can cause the compiler + * to 'give up' if used with excessively deep types, so use sparingly. + * + * @see {@link https://github.com/mmkal/expect-type/pull/21 | Reference} + */ + branded: { + /** + * Uses TypeScript's internal technique to check for type "identicalness". + * + * It will check if the types are fully equal to each other. + * It will not fail if two objects have different values, but the same type. + * It will fail however if an object is missing a property. + * + * **_Unexpected failure_**? For a more permissive but less performant + * check that accommodates for equivalent intersection types, + * use {@linkcode PositiveExpectTypeOf.branded | .branded.toEqualTypeOf()}. + * @see {@link https://github.com/mmkal/expect-type#why-is-my-assertion-failing | The documentation for details}. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toEqualTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 1 }) + * + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 2 }) + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toEqualTypeOf: extends true ? unknown : MismatchInfo>(...MISMATCH: MismatchArgs, true>) => true; + }; +} +/** + * Represents the negative expectation type for the {@linkcode Actual} type. + */ +export interface NegativeExpectTypeOf extends BaseExpectTypeOf { + /** + * Similar to jest's `expect(...).toMatchObject(...)` but for types. + * Deeply "picks" the properties of the actual type based on the expected type, then performs a strict check to make sure the types match `Expected`. + * + * **Note**: optional properties on the {@linkcode Expected | expected type} are not allowed to be missing on the {@linkcode Actual | actual type}. + * + * @example + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchObjectType<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toMatchObjectType<{ a: number; c?: number }>() + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toMatchObjectType: (...MISMATCH: MismatchArgs, Expected>, false>) => true; + /** + * Check if your type extends the expected type + * + * A less strict version of {@linkcode PositiveExpectTypeOf.toEqualTypeOf | .toEqualTypeOf()} that allows for extra properties. + * This is roughly equivalent to an `extends` constraint in a function type argument. + * + * @example + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toExtend<{ a: number }>()] + * + * expectTypeOf({ a: 1 }).not.toExtend<{ b: number }>() + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toExtend(...MISMATCH: MismatchArgs, false>): true; + toEqualTypeOf: { + /** + * Uses TypeScript's internal technique to check for type "identicalness". + * + * It will check if the types are fully equal to each other. + * It will not fail if two objects have different values, but the same type. + * It will fail however if an object is missing a property. + * + * **_Unexpected failure_**? For a more permissive but less performant + * check that accommodates for equivalent intersection types, + * use {@linkcode PositiveExpectTypeOf.branded | .branded.toEqualTypeOf()}. + * @see {@link https://github.com/mmkal/expect-type#why-is-my-assertion-failing | The documentation for details}. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toEqualTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 1 }) + * + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 2 }) + * ``` + * + * @param value - The value to compare against the expected type. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + (value: Expected & AValue, ...MISMATCH: MismatchArgs, false>): true; + /** + * Uses TypeScript's internal technique to check for type "identicalness". + * + * It will check if the types are fully equal to each other. + * It will not fail if two objects have different values, but the same type. + * It will fail however if an object is missing a property. + * + * **_Unexpected failure_**? For a more permissive but less performant + * check that accommodates for equivalent intersection types, + * use {@linkcode PositiveExpectTypeOf.branded | .branded.toEqualTypeOf()}. + * @see {@link https://github.com/mmkal/expect-type#why-is-my-assertion-failing | The documentation for details}. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf<{ a: number }>() + * + * expectTypeOf({ a: 1, b: 1 }).not.toEqualTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 1 }) + * + * expectTypeOf({ a: 1 }).toEqualTypeOf({ a: 2 }) + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + (...MISMATCH: MismatchArgs, false>): true; + }; + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + */ + toMatchTypeOf: { + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + * + * A less strict version of + * {@linkcode PositiveExpectTypeOf.toEqualTypeOf | .toEqualTypeOf()} + * that allows for extra properties. + * This is roughly equivalent to an `extends` constraint + * in a function type argument. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf({ a: 2 }) + * ``` + * + * @param value - The value to compare against the expected type. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + (value: Expected & AValue, // reason for `& AValue`: make sure this is only the selected overload when the end-user passes a value for an inferred typearg. The `Mismatch` type does match `AValue`. + ...MISMATCH: MismatchArgs, false>): true; + /** + * @deprecated Since v1.2.0 - Use either {@linkcode toMatchObjectType} or {@linkcode toExtend} instead + * + * - Use {@linkcode toMatchObjectType} to perform a strict check on a subset of your type's keys + * - Use {@linkcode toExtend} to check if your type extends the expected type + * + * A less strict version of + * {@linkcode PositiveExpectTypeOf.toEqualTypeOf | .toEqualTypeOf()} + * that allows for extra properties. + * This is roughly equivalent to an `extends` constraint + * in a function type argument. + * + * @example + * Using generic type argument syntax + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf<{ a: number }>() + * ``` + * + * @example + * Using inferred type syntax by passing a value + * ```ts + * expectTypeOf({ a: 1, b: 1 }).toMatchTypeOf({ a: 2 }) + * ``` + * + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + (...MISMATCH: MismatchArgs, false>): true; + }; + /** + * Checks whether an object has a given property. + * + * @example + * check that properties exist + * ```ts + * const obj = { a: 1, b: '' } + * + * expectTypeOf(obj).toHaveProperty('a') + * + * expectTypeOf(obj).not.toHaveProperty('c') + * ``` + * + * @param key - The property key to check for. + * @param MISMATCH - The mismatch arguments. + * @returns `true`. + */ + toHaveProperty: (key: KeyType, ...MISMATCH: MismatchArgs, false>) => true; +} +/** + * Represents a conditional type that selects either + * {@linkcode PositiveExpectTypeOf} or {@linkcode NegativeExpectTypeOf} based + * on the value of the `positive` property in the {@linkcode Options} type. + */ +export type ExpectTypeOf = Options['positive'] extends true ? PositiveExpectTypeOf : NegativeExpectTypeOf; +/** + * Represents the base interface for the + * {@linkcode expectTypeOf()} function. + * Provides a set of assertion methods to perform type checks on a value. + */ +export interface BaseExpectTypeOf { + /** + * Checks whether the type of the value is `any`. + */ + toBeAny: Scolder, Options>; + /** + * Checks whether the type of the value is `unknown`. + */ + toBeUnknown: Scolder, Options>; + /** + * Checks whether the type of the value is `never`. + */ + toBeNever: Scolder, Options>; + /** + * Checks whether the type of the value is `function`. + */ + toBeFunction: Scolder, Options>; + /** + * Checks whether the type of the value is `object`. + */ + toBeObject: Scolder, Options>; + /** + * Checks whether the type of the value is an {@linkcode Array}. + */ + toBeArray: Scolder, Options>; + /** + * Checks whether the type of the value is `number`. + */ + toBeNumber: Scolder, Options>; + /** + * Checks whether the type of the value is `string`. + */ + toBeString: Scolder, Options>; + /** + * Checks whether the type of the value is `boolean`. + */ + toBeBoolean: Scolder, Options>; + /** + * Checks whether the type of the value is `void`. + */ + toBeVoid: Scolder, Options>; + /** + * Checks whether the type of the value is `symbol`. + */ + toBeSymbol: Scolder, Options>; + /** + * Checks whether the type of the value is `null`. + */ + toBeNull: Scolder, Options>; + /** + * Checks whether the type of the value is `undefined`. + */ + toBeUndefined: Scolder, Options>; + /** + * Checks whether the type of the value is `null` or `undefined`. + */ + toBeNullable: Scolder, Options>; + /** + * Transform that type of the value via a callback. + * + * @param fn - A callback that transforms the input value. Note that this function is not actually called - it's only used for type inference. + * @returns A new type which can be used for further assertions. + */ + map: (fn: (value: Actual) => T) => ExpectTypeOf; + /** + * Checks whether the type of the value is **`bigint`**. + * + * @example + * #### Distinguish between **`number`** and **`bigint`** + * + * ```ts + * import { expectTypeOf } from 'expect-type' + * + * const aVeryBigInteger = 10n ** 100n + * + * expectTypeOf(aVeryBigInteger).not.toBeNumber() + * + * expectTypeOf(aVeryBigInteger).toBeBigInt() + * ``` + * + * @since 1.1.0 + */ + toBeBigInt: Scolder, Options>; + /** + * Checks whether a function is callable with the given parameters. + * + * __Note__: You cannot negate this assertion with + * {@linkcode PositiveExpectTypeOf.not | .not}, you need to use + * `ts-expect-error` instead. + * + * @example + * ```ts + * const f = (a: number) => [a, a] + * + * expectTypeOf(f).toBeCallableWith(1) + * ``` + * + * __Known Limitation__: This assertion will likely fail if you try to use it + * with a generic function or an overload. + * @see {@link https://github.com/mmkal/expect-type/issues/50 | This issue} for an example and a workaround. + * + * @param args - The arguments to check for callability. + * @returns `true`. + */ + toBeCallableWith: Options['positive'] extends true ? >(...args: Args) => ExpectTypeOf, Options> : never; + /** + * Checks whether a class is constructible with the given parameters. + * + * @example + * ```ts + * expectTypeOf(Date).toBeConstructibleWith('1970') + * + * expectTypeOf(Date).toBeConstructibleWith(0) + * + * expectTypeOf(Date).toBeConstructibleWith(new Date()) + * + * expectTypeOf(Date).toBeConstructibleWith() + * ``` + * + * @param args - The arguments to check for constructibility. + * @returns `true`. + */ + toBeConstructibleWith: Options['positive'] extends true ? >(...args: Args) => true : never; + /** + * Equivalent to the {@linkcode Extract} utility type. + * Helps narrow down complex union types. + * + * @example + * ```ts + * type ResponsiveProp = T | T[] | { xs?: T; sm?: T; md?: T } + * + * interface CSSProperties { + * margin?: string + * padding?: string + * } + * + * function getResponsiveProp(_props: T): ResponsiveProp { + * return {} + * } + * + * const cssProperties: CSSProperties = { margin: '1px', padding: '2px' } + * + * expectTypeOf(getResponsiveProp(cssProperties)) + * .extract<{ xs?: any }>() // extracts the last type from a union + * .toEqualTypeOf<{ + * xs?: CSSProperties + * sm?: CSSProperties + * md?: CSSProperties + * }>() + * + * expectTypeOf(getResponsiveProp(cssProperties)) + * .extract() // extracts an array from a union + * .toEqualTypeOf() + * ``` + * + * __Note__: If no type is found in the union, it will return `never`. + * + * @param v - The type to extract from the union. + * @returns The type after extracting the type from the union. + */ + extract: (v?: V) => ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode Exclude} utility type. + * Removes types from a union. + * + * @example + * ```ts + * type ResponsiveProp = T | T[] | { xs?: T; sm?: T; md?: T } + * + * interface CSSProperties { + * margin?: string + * padding?: string + * } + * + * function getResponsiveProp(_props: T): ResponsiveProp { + * return {} + * } + * + * const cssProperties: CSSProperties = { margin: '1px', padding: '2px' } + * + * expectTypeOf(getResponsiveProp(cssProperties)) + * .exclude() + * .exclude<{ xs?: unknown }>() // or just `.exclude()` + * .toEqualTypeOf() + * ``` + */ + exclude: (v?: V) => ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode Pick} utility type. + * Helps select a subset of properties from an object type. + * + * @example + * ```ts + * interface Person { + * name: string + * age: number + * } + * + * expectTypeOf() + * .pick<'name'>() + * .toEqualTypeOf<{ name: string }>() + * ``` + * + * @param keyToPick - The property key to pick. + * @returns The type after picking the property. + */ + pick: (keyToPick?: KeyToPick) => ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode Omit} utility type. + * Helps remove a subset of properties from an object type. + * + * @example + * ```ts + * interface Person { + * name: string + * age: number + * } + * + * expectTypeOf().omit<'name'>().toEqualTypeOf<{ age: number }>() + * ``` + * + * @param keyToOmit - The property key to omit. + * @returns The type after omitting the property. + */ + omit: )>(keyToOmit?: KeyToOmit) => ExpectTypeOf, Options>; + /** + * Extracts a certain function argument with `.parameter(number)` call to + * perform other assertions on it. + * + * @example + * ```ts + * function foo(a: number, b: string) { + * return [a, b] + * } + * + * expectTypeOf(foo).parameter(0).toBeNumber() + * + * expectTypeOf(foo).parameter(1).toBeString() + * ``` + * + * @param index - The index of the parameter to extract. + * @returns The extracted parameter type. + */ + parameter: (index: Index) => ExpectTypeOf[Index], Options>; + /** + * Equivalent to the {@linkcode Parameters} utility type. + * Extracts function parameters to perform assertions on its value. + * Parameters are returned as an array. + * + * @example + * ```ts + * function noParam() {} + * + * function hasParam(s: string) {} + * + * expectTypeOf(noParam).parameters.toEqualTypeOf<[]>() + * + * expectTypeOf(hasParam).parameters.toEqualTypeOf<[string]>() + * ``` + */ + parameters: ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode ConstructorParameters} utility type. + * Extracts constructor parameters as an array of values and + * perform assertions on them with this method. + * + * For overloaded constructors it will return a union of all possible parameter-tuples. + * + * @example + * ```ts + * expectTypeOf(Date).constructorParameters.toEqualTypeOf< + * [] | [string | number | Date] + * >() + * ``` + */ + constructorParameters: ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode ThisParameterType} utility type. + * Extracts the `this` parameter of a function to + * perform assertions on its value. + * + * @example + * ```ts + * function greet(this: { name: string }, message: string) { + * return `Hello ${this.name}, here's your message: ${message}` + * } + * + * expectTypeOf(greet).thisParameter.toEqualTypeOf<{ name: string }>() + * ``` + */ + thisParameter: ExpectTypeOf, Options>; + /** + * Equivalent to the {@linkcode InstanceType} utility type. + * Extracts the instance type of a class to perform assertions on. + * + * @example + * ```ts + * expectTypeOf(Date).instance.toHaveProperty('toISOString') + * ``` + */ + instance: Actual extends new (...args: any[]) => infer I ? ExpectTypeOf : never; + /** + * Equivalent to the {@linkcode ReturnType} utility type. + * Extracts the return type of a function. + * + * @example + * ```ts + * expectTypeOf(() => {}).returns.toBeVoid() + * + * expectTypeOf((a: number) => [a, a]).returns.toEqualTypeOf([1, 2]) + * ``` + */ + returns: Actual extends Function ? ExpectTypeOf, Options> : never; + /** + * Extracts resolved value of a Promise, + * so you can perform other assertions on it. + * + * @example + * ```ts + * async function asyncFunc() { + * return 123 + * } + * + * expectTypeOf(asyncFunc).returns.resolves.toBeNumber() + * + * expectTypeOf(Promise.resolve('string')).resolves.toBeString() + * ``` + * + * Type Equivalent: + * ```ts + * type Resolves = PromiseType extends PromiseLike + * ? ResolvedType + * : never + * ``` + */ + resolves: Actual extends PromiseLike ? ExpectTypeOf : never; + /** + * Extracts array item type to perform assertions on. + * + * @example + * ```ts + * expectTypeOf([1, 2, 3]).items.toEqualTypeOf() + * + * expectTypeOf([1, 2, 3]).items.not.toEqualTypeOf() + * ``` + * + * __Type Equivalent__: + * ```ts + * type Items = ArrayType extends ArrayLike + * ? ItemType + * : never + * ``` + */ + items: Actual extends ArrayLike ? ExpectTypeOf : never; + /** + * Extracts the type guarded by a function to perform assertions on. + * + * @example + * ```ts + * function isString(v: any): v is string { + * return typeof v === 'string' + * } + * + * expectTypeOf(isString).guards.toBeString() + * ``` + */ + guards: Actual extends (v: any, ...args: any[]) => v is infer T ? ExpectTypeOf : never; + /** + * Extracts the type asserted by a function to perform assertions on. + * + * @example + * ```ts + * function assertNumber(v: any): asserts v is number { + * if (typeof v !== 'number') + * throw new TypeError('Nope !') + * } + * + * expectTypeOf(assertNumber).asserts.toBeNumber() + * ``` + */ + asserts: Actual extends (v: any, ...args: any[]) => asserts v is infer T ? unknown extends T ? never : ExpectTypeOf : never; +} +/** + * Represents a function that allows asserting the expected type of a value. + */ +export type _ExpectTypeOf = { + /** + * Asserts the expected type of a value. + * + * @param actual - The actual value being asserted. + * @returns An object representing the expected type assertion. + */ + (actual: Actual): ExpectTypeOf; + /** + * Asserts the expected type of a value without providing an actual value. + * + * @returns An object representing the expected type assertion. + */ + (): ExpectTypeOf; +}; +/** + * Similar to Jest's `expect`, but with type-awareness. + * Gives you access to a number of type-matchers that let you make assertions about the + * form of a reference or generic type parameter. + * + * @example + * ```ts + * import { foo, bar } from '../foo' + * import { expectTypeOf } from 'expect-type' + * + * test('foo types', () => { + * // make sure `foo` has type { a: number } + * expectTypeOf(foo).toMatchTypeOf({ a: 1 }) + * expectTypeOf(foo).toHaveProperty('a').toBeNumber() + * + * // make sure `bar` is a function taking a string: + * expectTypeOf(bar).parameter(0).toBeString() + * expectTypeOf(bar).returns.not.toBeAny() + * }) + * ``` + * + * @description + * See the [full docs](https://npmjs.com/package/expect-type#documentation) for lots more examples. + */ +export declare const expectTypeOf: _ExpectTypeOf; diff --git a/tools/ui/node_modules/expect-type/dist/index.js b/tools/ui/node_modules/expect-type/dist/index.js new file mode 100644 index 0000000000000000000000000000000000000000..55e299ec5099998e5bfd3c25b037296d7ceee0a2 --- /dev/null +++ b/tools/ui/node_modules/expect-type/dist/index.js @@ -0,0 +1,96 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.expectTypeOf = void 0; +__exportStar(require("./branding"), exports); // backcompat, consider removing in next major version +__exportStar(require("./messages"), exports); // backcompat, consider removing in next major version +__exportStar(require("./overloads"), exports); +__exportStar(require("./utils"), exports); // backcompat, consider removing in next major version +const fn = () => true; +/** + * Similar to Jest's `expect`, but with type-awareness. + * Gives you access to a number of type-matchers that let you make assertions about the + * form of a reference or generic type parameter. + * + * @example + * ```ts + * import { foo, bar } from '../foo' + * import { expectTypeOf } from 'expect-type' + * + * test('foo types', () => { + * // make sure `foo` has type { a: number } + * expectTypeOf(foo).toMatchTypeOf({ a: 1 }) + * expectTypeOf(foo).toHaveProperty('a').toBeNumber() + * + * // make sure `bar` is a function taking a string: + * expectTypeOf(bar).parameter(0).toBeString() + * expectTypeOf(bar).returns.not.toBeAny() + * }) + * ``` + * + * @description + * See the [full docs](https://npmjs.com/package/expect-type#documentation) for lots more examples. + */ +const expectTypeOf = (_actual) => { + const nonFunctionProperties = [ + 'parameters', + 'returns', + 'resolves', + 'not', + 'items', + 'constructorParameters', + 'thisParameter', + 'instance', + 'guards', + 'asserts', + 'branded', + ]; + const obj = { + /* eslint-disable @typescript-eslint/no-unsafe-assignment */ + toBeAny: fn, + toBeUnknown: fn, + toBeNever: fn, + toBeFunction: fn, + toBeObject: fn, + toBeArray: fn, + toBeString: fn, + toBeNumber: fn, + toBeBoolean: fn, + toBeVoid: fn, + toBeSymbol: fn, + toBeNull: fn, + toBeUndefined: fn, + toBeNullable: fn, + toBeBigInt: fn, + toMatchTypeOf: fn, + toEqualTypeOf: fn, + toBeConstructibleWith: fn, + toMatchObjectType: fn, + toExtend: fn, + map: exports.expectTypeOf, + toBeCallableWith: exports.expectTypeOf, + extract: exports.expectTypeOf, + exclude: exports.expectTypeOf, + pick: exports.expectTypeOf, + omit: exports.expectTypeOf, + toHaveProperty: exports.expectTypeOf, + parameter: exports.expectTypeOf, + }; + const getterProperties = nonFunctionProperties; + getterProperties.forEach((prop) => Object.defineProperty(obj, prop, { get: () => (0, exports.expectTypeOf)({}) })); + return obj; +}; +exports.expectTypeOf = expectTypeOf; diff --git a/tools/ui/node_modules/expect-type/dist/messages.d.ts b/tools/ui/node_modules/expect-type/dist/messages.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d8de9bedd70e8fec408d3375d416c0d681929cdc --- /dev/null +++ b/tools/ui/node_modules/expect-type/dist/messages.d.ts @@ -0,0 +1,168 @@ +import type { StrictEqualUsingBranding } from './branding'; +import type { And, Extends, ExtendsExcludingAnyOrNever, IsAny, IsNever, IsUnknown, Not, OptionalKeys, UsefulKeys } from './utils'; +/** + * Determines the printable type representation for a given type. + */ +export type PrintType = IsUnknown extends true ? 'unknown' : IsNever extends true ? 'never' : IsAny extends true ? never : boolean extends T ? 'boolean' : T extends boolean ? `literal boolean: ${T}` : string extends T ? 'string' : T extends string ? `literal string: ${T}` : number extends T ? 'number' : T extends number ? `literal number: ${T}` : bigint extends T ? 'bigint' : T extends bigint ? `literal bigint: ${T}` : T extends null ? 'null' : T extends undefined ? 'undefined' : T extends (...args: any[]) => any ? 'function' : '...'; +/** + * Helper for showing end-user a hint why their type assertion is failing. + * This swaps "leaf" types with a literal message about what the actual and + * expected types are. Needs to check for `Not>` because + * otherwise `LeafTypeOf` returns `never`, which extends everything 🤔 + */ +export type MismatchInfo = And<[Extends, '...'>, Not>]> extends true ? And<[Extends, Extends]> extends true ? Array[number], Extract[number]>> : Optionalify<{ + [K in UsefulKeys | UsefulKeys]: MismatchInfo; +}, OptionalKeys> : StrictEqualUsingBranding extends true ? Actual : `Expected: ${PrintType}, Actual: ${PrintType>}`; +/** + * Helper for making some keys of a type optional. Only useful so far for `MismatchInfo` - it makes sure we + * don't get bogus errors about optional properties mismatching, when actually it's something else that's wrong. + * + * - Note: this helper is a no-op if there are no optional keys in the type. + */ +export type Optionalify = [TOptionalKeys] extends [never] ? T : ({ + [K in Exclude]: T[K]; +} & { + [K in Extract]?: T[K]; +}) extends infer X ? { + [K in keyof X]: X[K]; +} : never; +/** + * @internal + */ +declare const inverted: unique symbol; +/** + * @internal + */ +type Inverted = { + [inverted]: T; +}; +/** + * @internal + */ +declare const expectNull: unique symbol; +export type ExpectNull = { + [expectNull]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectUndefined: unique symbol; +export type ExpectUndefined = { + [expectUndefined]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectNumber: unique symbol; +export type ExpectNumber = { + [expectNumber]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectString: unique symbol; +export type ExpectString = { + [expectString]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectBoolean: unique symbol; +export type ExpectBoolean = { + [expectBoolean]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectVoid: unique symbol; +export type ExpectVoid = { + [expectVoid]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectFunction: unique symbol; +export type ExpectFunction = { + [expectFunction]: T; + result: ExtendsExcludingAnyOrNever any>; +}; +/** + * @internal + */ +declare const expectObject: unique symbol; +export type ExpectObject = { + [expectObject]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectArray: unique symbol; +export type ExpectArray = { + [expectArray]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectSymbol: unique symbol; +export type ExpectSymbol = { + [expectSymbol]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * @internal + */ +declare const expectAny: unique symbol; +export type ExpectAny = { + [expectAny]: T; + result: IsAny; +}; +/** + * @internal + */ +declare const expectUnknown: unique symbol; +export type ExpectUnknown = { + [expectUnknown]: T; + result: IsUnknown; +}; +/** + * @internal + */ +declare const expectNever: unique symbol; +export type ExpectNever = { + [expectNever]: T; + result: IsNever; +}; +/** + * @internal + */ +declare const expectNullable: unique symbol; +export type ExpectNullable = { + [expectNullable]: T; + result: Not>>; +}; +/** + * @internal + */ +declare const expectBigInt: unique symbol; +export type ExpectBigInt = { + [expectBigInt]: T; + result: ExtendsExcludingAnyOrNever; +}; +/** + * Checks if the result of an expecter matches the specified options, and + * resolves to a fairly readable error message if not. + */ +export type Scolder = Expecter['result'] extends Options['positive'] ? () => true : Options['positive'] extends true ? Expecter : Inverted; +export {}; diff --git a/tools/ui/node_modules/expect-type/dist/messages.js b/tools/ui/node_modules/expect-type/dist/messages.js new file mode 100644 index 0000000000000000000000000000000000000000..ff4e0ae9d1cc506042d41c1b91cf85e5ed6c93c6 --- /dev/null +++ b/tools/ui/node_modules/expect-type/dist/messages.js @@ -0,0 +1,66 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * @internal + */ +const inverted = Symbol('inverted'); +/** + * @internal + */ +const expectNull = Symbol('expectNull'); +/** + * @internal + */ +const expectUndefined = Symbol('expectUndefined'); +/** + * @internal + */ +const expectNumber = Symbol('expectNumber'); +/** + * @internal + */ +const expectString = Symbol('expectString'); +/** + * @internal + */ +const expectBoolean = Symbol('expectBoolean'); +/** + * @internal + */ +const expectVoid = Symbol('expectVoid'); +/** + * @internal + */ +const expectFunction = Symbol('expectFunction'); +/** + * @internal + */ +const expectObject = Symbol('expectObject'); +/** + * @internal + */ +const expectArray = Symbol('expectArray'); +/** + * @internal + */ +const expectSymbol = Symbol('expectSymbol'); +/** + * @internal + */ +const expectAny = Symbol('expectAny'); +/** + * @internal + */ +const expectUnknown = Symbol('expectUnknown'); +/** + * @internal + */ +const expectNever = Symbol('expectNever'); +/** + * @internal + */ +const expectNullable = Symbol('expectNullable'); +/** + * @internal + */ +const expectBigInt = Symbol('expectBigInt'); diff --git a/tools/ui/node_modules/expect-type/dist/overloads.d.ts b/tools/ui/node_modules/expect-type/dist/overloads.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ab0e22ed8f4a40859c0a9424e9f7a8434086f192 --- /dev/null +++ b/tools/ui/node_modules/expect-type/dist/overloads.d.ts @@ -0,0 +1,288 @@ +import type { StrictEqualUsingTSInternalIdenticalToOperator, IsNever, UnionToIntersection, UnionToTuple } from './utils'; +/** + * The simple(ish) way to get overload info from a function + * {@linkcode FunctionType}. Recent versions of TypeScript will match any + * function against a generic 10-overload type, filling in slots with + * duplicates of the function. So, we can just match against a single type + * and get all the overloads. + * + * For older versions of TypeScript, we'll need to painstakingly do + * ten separate matches. + */ +export type TSPost53OverloadsInfoUnion = FunctionType extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; + (...args: infer A7): infer R7; + (...args: infer A8): infer R8; + (...args: infer A9): infer R9; + (...args: infer A10): infer R10; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) | ((...p: A10) => R10) : never; +/** + * A function with `unknown` parameters and return type. + */ +export type UnknownFunction = (...args: unknown[]) => unknown; +/** + * `true` iff {@linkcode FunctionType} is + * equivalent to `(...args: unknown[]) => unknown`, + * which is what an overload variant looks like for a non-existent overload. + * This is useful because older versions of TypeScript end up with + * 9 "useless" overloads and one real one for parameterless/generic functions. + * + * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related} + */ +export type IsUselessOverloadInfo = StrictEqualUsingTSInternalIdenticalToOperator; +/** + * Old versions of TypeScript can sometimes seem to refuse to separate out + * union members unless you put them each in a pointless tuple and add an + * extra `infer X` expression. There may be a better way to work around this + * problem, but since it's not a problem in newer versions of TypeScript, + * it's not a priority right now. + */ +export type Tuplify = Union extends infer X ? [X] : never; +/** + * For older versions of TypeScript, we need two separate workarounds + * to get overload info. First, we need need to use + * {@linkcode DecreasingOverloadsInfoUnion} to get the overload info for + * functions with 1-10 overloads. Then, we need to filter out the + * "useless" overloads that are present in older versions of TypeScript, + * for parameterless functions. To do this we use + * {@linkcode IsUselessOverloadInfo} to remove useless overloads. + * + * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related} + */ +export type TSPre53OverloadsInfoUnion = Tuplify> extends infer Tup ? Tup extends [infer Fn] ? IsUselessOverloadInfo extends true ? never : Fn : never : never; +/** + * For versions of TypeScript below 5.3, we need to check for 10 overloads, + * then 9, then 8, etc., to get a union of the overload variants. + */ +export type DecreasingOverloadsInfoUnion = F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; + (...args: infer A7): infer R7; + (...args: infer A8): infer R8; + (...args: infer A9): infer R9; + (...args: infer A10): infer R10; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) | ((...p: A10) => R10) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; + (...args: infer A7): infer R7; + (...args: infer A8): infer R8; + (...args: infer A9): infer R9; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) | ((...p: A9) => R9) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; + (...args: infer A7): infer R7; + (...args: infer A8): infer R8; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) | ((...p: A8) => R8) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; + (...args: infer A7): infer R7; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) | ((...p: A7) => R7) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; + (...args: infer A6): infer R6; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) | ((...p: A6) => R6) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; + (...args: infer A5): infer R5; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) | ((...p: A5) => R5) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; + (...args: infer A4): infer R4; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) | ((...p: A4) => R4) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; + (...args: infer A3): infer R3; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) | ((...p: A3) => R3) : F extends { + (...args: infer A1): infer R1; + (...args: infer A2): infer R2; +} ? ((...p: A1) => R1) | ((...p: A2) => R2) : F extends (...args: infer A1) => infer R1 ? ((...p: A1) => R1) : never; +/** + * Get a union of overload variants for a function {@linkcode FunctionType}. + * Does a check for whether we can do the one-shot + * 10-overload matcher (which works for ts\>5.3), and if not, + * falls back to the more complicated utility. + */ +export type OverloadsInfoUnion = IsNever 2>> extends true ? TSPre53OverloadsInfoUnion : TSPost53OverloadsInfoUnion; +/** + * Allows inferring any function using the `infer` keyword. + */ +export type InferFunctionType any> = FunctionType; +/** + * A union type of the parameters allowed for any + * overload of function {@linkcode FunctionType}. + */ +export type OverloadParameters = OverloadsInfoUnion extends InferFunctionType ? Parameters : never; +/** + * A union type of the return types for any overload of + * function {@linkcode FunctionType}. + */ +export type OverloadReturnTypes = OverloadsInfoUnion extends InferFunctionType ? ReturnType : never; +/** + * Takes an overload variants {@linkcode Union}, + * produced from {@linkcode OverloadsInfoUnion} and rejects + * the ones incompatible with parameters {@linkcode Args}. + */ +export type SelectOverloadsInfo = Union extends InferFunctionType ? (Args extends Parameters ? Fn : never) : never; +/** + * Creates a new overload (an intersection type) from an existing one, + * which only includes variant(s) which can accept + * {@linkcode Args} as parameters. + */ +export type OverloadsNarrowedByParameters> = UnionToIntersection, Args>>; +/** + * The simple(ish) way to get overload info from a constructor + * {@linkcode ConstructorType}. Recent versions of TypeScript will match any + * constructor against a generic 10-overload type, filling in slots with + * duplicates of the constructor. So, we can just match against a single type + * and get all the overloads. + * + * For older versions of TypeScript, + * we'll need to painstakingly do ten separate matches. + */ +export type TSPost53ConstructorOverloadsInfoUnion = ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; + new (...args: infer A7): infer R7; + new (...args: infer A8): infer R8; + new (...args: infer A9): infer R9; + new (...args: infer A10): infer R10; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) | (new (...p: A10) => R10) : never; +/** + * A constructor function with `unknown` parameters and return type. + */ +export type UnknownConstructor = new (...args: unknown[]) => unknown; +/** + * Same as {@linkcode IsUselessOverloadInfo}, but for constructors. + */ +export type IsUselessConstructorOverloadInfo = StrictEqualUsingTSInternalIdenticalToOperator; +/** + * For older versions of TypeScript, we need two separate workarounds to + * get constructor overload info. First, we need need to use + * {@linkcode DecreasingConstructorOverloadsInfoUnion} to get the overload + * info for constructors with 1-10 overloads. Then, we need to filter out the + * "useless" overloads that are present in older versions of TypeScript, + * for parameterless constructors. To do this we use + * {@linkcode IsUselessConstructorOverloadInfo} to remove useless overloads. + * + * @see {@link https://github.com/microsoft/TypeScript/issues/28867 | Related} + */ +export type TSPre53ConstructorOverloadsInfoUnion = Tuplify> extends infer Tup ? Tup extends [infer Ctor] ? IsUselessConstructorOverloadInfo extends true ? never : Ctor : never : never; +/** + * For versions of TypeScript below 5.3, we need to check for 10 overloads, + * then 9, then 8, etc., to get a union of the overload variants. + */ +export type DecreasingConstructorOverloadsInfoUnion = ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; + new (...args: infer A7): infer R7; + new (...args: infer A8): infer R8; + new (...args: infer A9): infer R9; + new (...args: infer A10): infer R10; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) | (new (...p: A10) => R10) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; + new (...args: infer A7): infer R7; + new (...args: infer A8): infer R8; + new (...args: infer A9): infer R9; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) | (new (...p: A9) => R9) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; + new (...args: infer A7): infer R7; + new (...args: infer A8): infer R8; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) | (new (...p: A8) => R8) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; + new (...args: infer A7): infer R7; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) | (new (...p: A7) => R7) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; + new (...args: infer A6): infer R6; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) | (new (...p: A6) => R6) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; + new (...args: infer A5): infer R5; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) | (new (...p: A5) => R5) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; + new (...args: infer A4): infer R4; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) | (new (...p: A4) => R4) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; + new (...args: infer A3): infer R3; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) | (new (...p: A3) => R3) : ConstructorType extends { + new (...args: infer A1): infer R1; + new (...args: infer A2): infer R2; +} ? (new (...p: A1) => R1) | (new (...p: A2) => R2) : ConstructorType extends new (...args: infer A1) => infer R1 ? (new (...p: A1) => R1) : never; +/** + * Get a union of overload variants for a constructor + * {@linkcode ConstructorType}. Does a check for whether we can do the + * one-shot 10-overload matcher (which works for ts\>5.3), and if not, + * falls back to the more complicated utility. + */ +export type ConstructorOverloadsUnion = IsNever any>> extends true ? TSPre53ConstructorOverloadsInfoUnion : TSPost53ConstructorOverloadsInfoUnion; +/** + * Allows inferring any constructor using the `infer` keyword. + */ +export type InferConstructor any> = ConstructorType; +/** + * A union type of the parameters allowed for any overload + * of constructor {@linkcode ConstructorType}. + */ +export type ConstructorOverloadParameters = ConstructorOverloadsUnion extends InferConstructor ? ConstructorParameters : never; +/** + * Calculates the number of overloads for a given function type. + */ +export type NumOverloads = UnionToTuple>['length']; diff --git a/tools/ui/node_modules/expect-type/dist/overloads.js b/tools/ui/node_modules/expect-type/dist/overloads.js new file mode 100644 index 0000000000000000000000000000000000000000..c8ad2e549bdc6801e0d1c80b0308d4b9bd4985ce --- /dev/null +++ b/tools/ui/node_modules/expect-type/dist/overloads.js @@ -0,0 +1,2 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/tools/ui/node_modules/expect-type/dist/utils.d.ts b/tools/ui/node_modules/expect-type/dist/utils.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..255624b43360e22825aeb9b007a63e4c94c49023 --- /dev/null +++ b/tools/ui/node_modules/expect-type/dist/utils.d.ts @@ -0,0 +1,197 @@ +/** + * Negates a boolean type. + */ +export type Not = T extends true ? false : true; +/** + * Returns `true` if at least one of the types in the + * {@linkcode Types} array is `true`, otherwise returns `false`. + */ +export type Or = Types[number] extends false ? false : true; +/** + * Checks if all the boolean types in the {@linkcode Types} array are `true`. + */ +export type And = Types[number] extends true ? true : false; +/** + * Represents an equality type that returns {@linkcode Right} if + * {@linkcode Left} is `true`, + * otherwise returns the negation of {@linkcode Right}. + */ +export type Eq = Left extends true ? Right : Not; +/** + * Represents the exclusive OR operation on a tuple of boolean types. + * Returns `true` if exactly one of the boolean types is `true`, + * otherwise returns `false`. + */ +export type Xor = Not>; +/** + * @internal + */ +declare const secret: unique symbol; +/** + * @internal + */ +type Secret = typeof secret; +/** + * Checks if the given type is `never`. + */ +export type IsNever = [T] extends [never] ? true : false; +/** + * Checks if the given type is `any`. + */ +export type IsAny = [T] extends [Secret] ? Not> : false; +/** + * Determines if the given type is `unknown`. + */ +export type IsUnknown = [unknown] extends [T] ? Not> : false; +/** + * Determines if a type is either `never` or `any`. + */ +export type IsNeverOrAny = Or<[IsNever, IsAny]>; +/** + * Subjective "useful" keys from a type. For objects it's just `keyof` but for + * tuples/arrays it's the number keys. + * + * @example + * ```ts + * UsefulKeys<{ a: 1; b: 2 }> // 'a' | 'b' + * + * UsefulKeys<['a', 'b']> // '0' | '1' + * + * UsefulKeys // number + * ``` + */ +export type UsefulKeys = T extends any[] ? { + [K in keyof T]: K; +}[number] : keyof T; +/** + * Extracts the keys from a type that are required (not optional). + */ +export type RequiredKeys = Extract<{ + [K in keyof T]-?: {} extends Pick ? never : K; +}[keyof T], keyof T>; +/** + * Gets the keys of an object type that are optional. + */ +export type OptionalKeys = Exclude>; +/** + * Extracts the keys from a type that are not `readonly`. + */ +export type ReadonlyKeys = Extract<{ + [K in keyof T]-?: ReadonlyEquivalent<{ + [_K in K]: T[K]; + }, { + -readonly [_K in K]: T[K]; + }> extends true ? never : K; +}[keyof T], keyof T>; +/** + * Determines if two types, are equivalent in a `readonly` manner. + * + * @internal + */ +type ReadonlyEquivalent = Extends<(() => T extends X ? true : false), (() => T extends Y ? true : false)>; +/** + * Checks if one type extends another. Note: this is not quite the same as `Left extends Right` because: + * 1. If either type is `never`, the result is `true` iff the other type is also `never`. + * 2. Types are wrapped in a 1-tuple so that union types are not distributed - instead we consider `string | number` to _not_ extend `number`. If we used `Left extends Right` directly you would get `Extends` => `false | true` => `boolean`. + */ +export type Extends = IsNever extends true ? IsNever : [Left] extends [Right] ? true : false; +/** + * Checks if the {@linkcode Left} type extends the {@linkcode Right} type, + * excluding `any` or `never`. + */ +export type ExtendsExcludingAnyOrNever = IsAny extends true ? IsAny : Extends; +/** + * Checks if two types are strictly equal using + * the TypeScript internal identical-to operator. + * + * @see {@link https://github.com/microsoft/TypeScript/issues/55188#issuecomment-1656328122 | much history} + */ +export type StrictEqualUsingTSInternalIdenticalToOperator = (() => T extends (L & T) | T ? true : false) extends () => T extends (R & T) | T ? true : false ? IsNever extends IsNever ? true : false : false; +/** + * Checks that {@linkcode Left} and {@linkcode Right} extend each other. + * Not quite the same as an equality check since `any` can make it resolve + * to `true`. So should only be used when {@linkcode Left} and + * {@linkcode Right} are known to avoid `any`. + */ +export type MutuallyExtends = And<[Extends, Extends]>; +/** + * @internal + */ +declare const mismatch: unique symbol; +/** + * @internal + */ +type Mismatch = { + [mismatch]: 'mismatch'; +}; +/** + * A type which should match anything passed as a value but *doesn't* + * match {@linkcode Mismatch}. It helps TypeScript select the right overload + * for {@linkcode PositiveExpectTypeOf.toEqualTypeOf | .toEqualTypeOf()} and + * {@linkcode PositiveExpectTypeOf.toMatchTypeOf | .toMatchTypeOf()}. + * + * @internal + */ +declare const avalue: unique symbol; +/** + * Represents a value that can be of various types. + */ +export type AValue = { + [avalue]?: undefined; +} | string | number | boolean | symbol | bigint | null | undefined | void; +/** + * Represents the type of mismatched arguments between + * the actual result and the expected result. + * + * If {@linkcode ActualResult} and {@linkcode ExpectedResult} are equivalent, + * the type resolves to an empty tuple `[]`, indicating no mismatch. + * If they are not equivalent, it resolves to a tuple containing the element + * {@linkcode Mismatch}, signifying a discrepancy between + * the expected and actual results. + */ +export type MismatchArgs = Eq extends true ? [] : [Mismatch]; +/** + * Represents the options for the {@linkcode ExpectTypeOf} function. + */ +export interface ExpectTypeOfOptions { + positive: boolean; + branded: boolean; +} +/** + * Convert a union to an intersection. + * `A | B | C` -\> `A & B & C` + */ +export type UnionToIntersection = (Union extends any ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection : never; +/** + * Get the last element of a union. + * First, converts to a union of `() => T` functions, + * then uses {@linkcode UnionToIntersection} to get the last one. + */ +export type LastOf = UnionToIntersection Union : never> extends () => infer R ? R : never; +/** + * Intermediate type for {@linkcode UnionToTuple} which pushes the + * "last" union member to the end of a tuple, and recursively prepends + * the remainder of the union. + */ +export type TuplifyUnion> = IsNever extends true ? [] : [...TuplifyUnion>, LastElement]; +/** + * Convert a union like `1 | 2 | 3` to a tuple like `[1, 2, 3]`. + */ +export type UnionToTuple = TuplifyUnion; +export type IsTuple = Or<[Extends, Extends]>; +export type IsUnion = Not['length'], 1>>; +/** + * A recursive version of `Pick` that selects properties from the left type that are present in the right type. + * The "leaf" types from `Left` are used - only the keys of `Right` are considered. + * + * @example + * ```ts + * const user = {email: 'a@b.com', name: 'John Doe', address: {street: '123 2nd St', city: 'New York', zip: '10001', state: 'NY', country: 'USA'}} + * + * type Result = DeepPickMatchingProps // {name: string, address: {city: string}} + * ``` + */ +export type DeepPickMatchingProps = Left extends Record ? Pick<{ + [K in keyof Left]: K extends keyof Right ? DeepPickMatchingProps : never; +}, Extract> : Left; +export {}; diff --git a/tools/ui/node_modules/expect-type/dist/utils.js b/tools/ui/node_modules/expect-type/dist/utils.js new file mode 100644 index 0000000000000000000000000000000000000000..43407cf45b806043a9d50df1746d538077bfeac4 --- /dev/null +++ b/tools/ui/node_modules/expect-type/dist/utils.js @@ -0,0 +1,19 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * @internal + */ +const secret = Symbol('secret'); +/** + * @internal + */ +const mismatch = Symbol('mismatch'); +/** + * A type which should match anything passed as a value but *doesn't* + * match {@linkcode Mismatch}. It helps TypeScript select the right overload + * for {@linkcode PositiveExpectTypeOf.toEqualTypeOf | .toEqualTypeOf()} and + * {@linkcode PositiveExpectTypeOf.toMatchTypeOf | .toMatchTypeOf()}. + * + * @internal + */ +const avalue = Symbol('avalue'); diff --git a/tools/ui/node_modules/expect-type/package.json b/tools/ui/node_modules/expect-type/package.json new file mode 100644 index 0000000000000000000000000000000000000000..8cc48b4765abaab89342a788af735086bd8f15e6 --- /dev/null +++ b/tools/ui/node_modules/expect-type/package.json @@ -0,0 +1,50 @@ +{ + "name": "expect-type", + "version": "1.3.0", + "engines": { + "node": ">=12.0.0" + }, + "keywords": [ + "typescript", + "type-check", + "assert", + "types", + "typings", + "test", + "testing" + ], + "homepage": "https://github.com/mmkal/expect-type#readme", + "repository": { + "type": "git", + "url": "https://github.com/mmkal/expect-type.git" + }, + "license": "Apache-2.0", + "main": "dist/index.js", + "types": "dist/index.d.ts", + "files": [ + "dist", + "*.md" + ], + "devDependencies": { + "@arethetypeswrong/cli": "0.17.3", + "@types/node": "^22.0.0", + "@typescript/native-preview": "7.0.0-dev.20250527.1", + "@vitest/ui": "^3.0.0", + "eslint": "^8.57.0", + "eslint-plugin-mmkal": "0.9.0", + "np": "^10.2.0", + "pkg-pr-new": "0.0.39", + "strip-ansi": "7.1.0", + "ts-morph": "23.0.0", + "typescript": "5.9.2", + "vitest": "^3.0.0" + }, + "scripts": { + "eslint": "eslint --max-warnings 0", + "lint": "tsc && pnpm eslint .", + "type-check": "tsc", + "build": "tsc -p tsconfig.lib.json", + "arethetypeswrong": "attw --pack", + "test": "vitest run" + } +} \ No newline at end of file diff --git a/tools/ui/node_modules/express-rate-limit/dist/index.cjs b/tools/ui/node_modules/express-rate-limit/dist/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..bea5307337b177a8584e1c53853da465c47864aa --- /dev/null +++ b/tools/ui/node_modules/express-rate-limit/dist/index.cjs @@ -0,0 +1,1016 @@ +"use strict"; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __export = (target, all) => { + for (var name in all) + __defProp(target, name, { get: all[name], enumerable: true }); +}; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") { + for (let key of __getOwnPropNames(from)) + if (!__hasOwnProp.call(to, key) && key !== except) + __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); + } + return to; +}; +var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); + +// source/index.ts +var index_exports = {}; +__export(index_exports, { + MemoryStore: () => MemoryStore, + default: () => rate_limit_default, + ipKeyGenerator: () => ipKeyGenerator, + rateLimit: () => rate_limit_default +}); +module.exports = __toCommonJS(index_exports); + +// source/ip-key-generator.ts +var import_node_net = require("node:net"); +var import_ip_address = require("ip-address"); +function ipKeyGenerator(ip, ipv6Subnet = 56) { + if ((0, import_node_net.isIPv6)(ip)) { + const address = new import_ip_address.Address6(ip); + if (address.is4()) return address.to4().correctForm(); + if (ipv6Subnet) { + const subnet = new import_ip_address.Address6(`${ip}/${ipv6Subnet}`); + return subnet.networkForm(); + } + } + return ip; +} + +// source/memory-store.ts +var MemoryStore = class { + constructor(validations2) { + this.validations = validations2; + /** + * These two maps store usage (requests) and reset time by key (for example, IP + * addresses or API keys). + * + * They are split into two to avoid having to iterate through the entire set to + * determine which ones need reset. Instead, `Client`s are moved from `previous` + * to `current` as they hit the endpoint. Once `windowMs` has elapsed, all clients + * left in `previous`, i.e., those that have not made any recent requests, are + * known to be expired and can be deleted in bulk. + */ + this.previous = /* @__PURE__ */ new Map(); + this.current = /* @__PURE__ */ new Map(); + /** + * Confirmation that the keys incremented in once instance of MemoryStore + * cannot affect other instances. + */ + this.localKeys = true; + } + /** + * Method that initializes the store. + * + * @param options {Options} - The options used to setup the middleware. + */ + init(options) { + this.windowMs = options.windowMs; + this.validations?.windowMs(this.windowMs); + if (this.interval) clearInterval(this.interval); + this.interval = setInterval(() => { + this.clearExpired(); + }, this.windowMs); + this.interval.unref?.(); + } + /** + * Method to fetch a client's hit count and reset time. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo | undefined} - The number of hits and reset time for that client. + * + * @public + */ + async get(key) { + return this.current.get(key) ?? this.previous.get(key); + } + /** + * Method to increment a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client. + * + * @public + */ + async increment(key) { + const client = this.getClient(key); + const now = Date.now(); + if (client.resetTime.getTime() <= now) { + this.resetClient(client, now); + } + client.totalHits++; + return client; + } + /** + * Method to decrement a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @public + */ + async decrement(key) { + const client = this.getClient(key); + if (client.totalHits > 0) client.totalHits--; + } + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @public + */ + async resetKey(key) { + this.current.delete(key); + this.previous.delete(key); + } + /** + * Method to reset everyone's hit counter. + * + * @public + */ + async resetAll() { + this.current.clear(); + this.previous.clear(); + } + /** + * Method to stop the timer (if currently running) and prevent any memory + * leaks. + * + * @public + */ + shutdown() { + clearInterval(this.interval); + void this.resetAll(); + } + /** + * Recycles a client by setting its hit count to zero, and reset time to + * `windowMs` milliseconds from now. + * + * NOT to be confused with `#resetKey()`, which removes a client from both the + * `current` and `previous` maps. + * + * @param client {Client} - The client to recycle. + * @param now {number} - The current time, to which the `windowMs` is added to get the `resetTime` for the client. + * + * @return {Client} - The modified client that was passed in, to allow for chaining. + */ + resetClient(client, now = Date.now()) { + client.totalHits = 0; + client.resetTime.setTime(now + this.windowMs); + return client; + } + /** + * Retrieves or creates a client, given a key. Also ensures that the client being + * returned is in the `current` map. + * + * @param key {string} - The key under which the client is (or is to be) stored. + * + * @returns {Client} - The requested client. + */ + getClient(key) { + if (this.current.has(key)) return this.current.get(key); + let client; + if (this.previous.has(key)) { + client = this.previous.get(key); + this.previous.delete(key); + } else { + client = { totalHits: 0, resetTime: /* @__PURE__ */ new Date() }; + this.resetClient(client); + } + this.current.set(key, client); + return client; + } + /** + * Move current clients to previous, create a new map for current. + * + * This function is called every `windowMs`. + */ + clearExpired() { + this.previous = this.current; + this.current = /* @__PURE__ */ new Map(); + } +}; + +// source/rate-limit.ts +var import_node_net3 = require("node:net"); + +// source/console-logger.ts +var ConsoleLogger = { + warn(...args) { + console.warn(...args.reverse()); + }, + error(...args) { + console.error(...args.reverse()); + } +}; + +// source/headers.ts +var import_node_buffer = require("node:buffer"); +var import_node_crypto = require("node:crypto"); +var SUPPORTED_DRAFT_VERSIONS = [ + "draft-6", + "draft-7", + "draft-8" +]; +var getResetSeconds = (windowMs, resetTime) => { + let resetSeconds; + if (resetTime) { + const deltaSeconds = Math.ceil((resetTime.getTime() - Date.now()) / 1e3); + resetSeconds = Math.max(0, deltaSeconds); + } else { + resetSeconds = Math.ceil(windowMs / 1e3); + } + return resetSeconds; +}; +var getPartitionKey = (key) => { + const hash = (0, import_node_crypto.createHash)("sha256"); + hash.update(key); + const partitionKey = hash.digest("hex").slice(0, 12); + return import_node_buffer.Buffer.from(partitionKey).toString("base64"); +}; +var setLegacyHeaders = (response, info) => { + if (response.headersSent) return; + response.setHeader("X-RateLimit-Limit", info.limit.toString()); + response.setHeader("X-RateLimit-Remaining", info.remaining.toString()); + if (info.resetTime instanceof Date) { + response.setHeader("Date", (/* @__PURE__ */ new Date()).toUTCString()); + response.setHeader( + "X-RateLimit-Reset", + Math.ceil(info.resetTime.getTime() / 1e3).toString() + ); + } +}; +var setDraft6Headers = (response, info, windowMs) => { + if (response.headersSent) return; + const windowSeconds = Math.ceil(windowMs / 1e3); + const resetSeconds = getResetSeconds(windowMs, info.resetTime); + response.setHeader("RateLimit-Policy", `${info.limit};w=${windowSeconds}`); + response.setHeader("RateLimit-Limit", info.limit.toString()); + response.setHeader("RateLimit-Remaining", info.remaining.toString()); + if (typeof resetSeconds === "number") + response.setHeader("RateLimit-Reset", resetSeconds.toString()); +}; +var setDraft7Headers = (response, info, windowMs) => { + if (response.headersSent) return; + const windowSeconds = Math.ceil(windowMs / 1e3); + const resetSeconds = getResetSeconds(windowMs, info.resetTime); + response.setHeader("RateLimit-Policy", `${info.limit};w=${windowSeconds}`); + response.setHeader( + "RateLimit", + `limit=${info.limit}, remaining=${info.remaining}, reset=${resetSeconds}` + ); +}; +var setDraft8Headers = (response, info, windowMs, name, key) => { + if (response.headersSent) return; + const windowSeconds = Math.ceil(windowMs / 1e3); + const resetSeconds = getResetSeconds(windowMs, info.resetTime); + const partitionKey = getPartitionKey(key); + const header = `r=${info.remaining}; t=${resetSeconds}`; + const policy = `q=${info.limit}; w=${windowSeconds}; pk=:${partitionKey}:`; + response.append("RateLimit", `"${name}"; ${header}`); + response.append("RateLimit-Policy", `"${name}"; ${policy}`); +}; +var setRetryAfterHeader = (response, info, windowMs) => { + if (response.headersSent) return; + const resetSeconds = getResetSeconds(windowMs, info.resetTime); + response.setHeader("Retry-After", resetSeconds.toString()); +}; + +// source/utils.ts +var omitUndefinedProperties = (passedOptions) => { + const omittedOptions = {}; + for (const k of Object.keys(passedOptions)) { + const key = k; + if (passedOptions[key] !== void 0) { + omittedOptions[key] = passedOptions[key]; + } + } + return omittedOptions; +}; + +// source/validations.ts +var import_node_net2 = require("node:net"); +var ValidationError = class extends Error { + /** + * The code must be a string, in snake case and all capital, that starts with + * the substring `ERR_ERL_`. + * + * The message must be a string, starting with an uppercase character, + * describing the issue in detail. + */ + constructor(code, message) { + const url = `https://express-rate-limit.github.io/${code}/`; + super(`${message} See ${url} for more information.`); + this.name = this.constructor.name; + this.code = code; + this.help = url; + } +}; +var ChangeWarning = class extends ValidationError { +}; +var usedStores = /* @__PURE__ */ new Set(); +var singleCountKeys = /* @__PURE__ */ new WeakMap(); +var validations = { + enabled: { + default: true + }, + // Should be EnabledValidations type, but that's a circular reference + disable() { + for (const k of Object.keys(this.enabled)) this.enabled[k] = false; + }, + /** + * Checks whether the IP address is valid, and that it does not have a port + * number in it. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_invalid_ip_address. + * + * @param ip {string | undefined} - The IP address provided by Express as request.ip. + * + * @returns {void} + */ + ip(ip) { + if (ip === void 0) { + throw new ValidationError( + "ERR_ERL_UNDEFINED_IP_ADDRESS", + `An undefined 'request.ip' was detected. This might indicate a misconfiguration or the connection being destroyed prematurely.` + ); + } + if (!(0, import_node_net2.isIP)(ip)) { + throw new ValidationError( + "ERR_ERL_INVALID_IP_ADDRESS", + `An invalid 'request.ip' (${ip}) was detected. Consider passing a custom 'keyGenerator' function to the rate limiter.` + ); + } + }, + /** + * Makes sure the trust proxy setting is not set to `true`. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_permissive_trust_proxy. + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + trustProxy(request) { + if (request.app.get("trust proxy") === true) { + throw new ValidationError( + "ERR_ERL_PERMISSIVE_TRUST_PROXY", + `The Express 'trust proxy' setting is true, which allows anyone to trivially bypass IP-based rate limiting.` + ); + } + }, + /** + * Makes sure the trust proxy setting is set in case the `X-Forwarded-For` + * header is present. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_unset_trust_proxy. + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + xForwardedForHeader(request) { + if (request.headers["x-forwarded-for"] && request.app.get("trust proxy") === false) { + throw new ValidationError( + "ERR_ERL_UNEXPECTED_X_FORWARDED_FOR", + `The 'X-Forwarded-For' header is set but the Express 'trust proxy' setting is false (default). This could indicate a misconfiguration which would prevent express-rate-limit from accurately identifying users.` + ); + } + }, + /** + * Alert the user if the Forwarded header is set (standardized version of X-Forwarded-For - not supported by express as of version 5.1.0) + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + forwardedHeader(request) { + if (request.headers.forwarded && request.ip === request.socket?.remoteAddress) { + throw new ValidationError( + "ERR_ERL_FORWARDED_HEADER", + `The 'Forwarded' header (standardized X-Forwarded-For) is set but currently being ignored. Add a custom keyGenerator to use a value from this header.` + ); + } + }, + /** + * Ensures totalHits value from store is a positive integer. + * + * @param hits {any} - The `totalHits` returned by the store. + */ + positiveHits(hits) { + if (typeof hits !== "number" || hits < 1 || hits !== Math.round(hits)) { + throw new ValidationError( + "ERR_ERL_INVALID_HITS", + `The totalHits value returned from the store must be a positive integer, got ${hits}` + ); + } + }, + /** + * Ensures a single store instance is not used with multiple express-rate-limit instances + */ + unsharedStore(store) { + if (usedStores.has(store)) { + const maybeUniquePrefix = store?.localKeys ? "" : " (with a unique prefix)"; + throw new ValidationError( + "ERR_ERL_STORE_REUSE", + `A Store instance must not be shared across multiple rate limiters. Create a new instance of ${store.constructor.name}${maybeUniquePrefix} for each limiter instead.` + ); + } + usedStores.add(store); + }, + /** + * Ensures a given key is incremented only once per request. + * + * @param request {Request} - The Express request object. + * @param store {Store} - The store class. + * @param key {string} - The key used to store the client's hit count. + * + * @returns {void} + */ + singleCount(request, store, key) { + let storeKeys = singleCountKeys.get(request); + if (!storeKeys) { + storeKeys = /* @__PURE__ */ new Map(); + singleCountKeys.set(request, storeKeys); + } + const storeKey = store.localKeys ? store : store.constructor.name; + let keys = storeKeys.get(storeKey); + if (!keys) { + keys = []; + storeKeys.set(storeKey, keys); + } + const prefixedKey = `${store.prefix ?? ""}${key}`; + if (keys.includes(prefixedKey)) { + throw new ValidationError( + "ERR_ERL_DOUBLE_COUNT", + `The hit count for ${key} was incremented more than once for a single request.` + ); + } + keys.push(prefixedKey); + }, + /** + * Warns the user that the behaviour for `max: 0` / `limit: 0` is + * changing in the next major release. + * + * @param limit {number} - The maximum number of hits per client. + * + * @returns {void} + */ + limit(limit) { + if (limit === 0) { + throw new ChangeWarning( + "WRN_ERL_MAX_ZERO", + "Setting limit or max to 0 disables rate limiting in express-rate-limit v6 and older, but will cause all requests to be blocked in v7" + ); + } + }, + /** + * Warns the user that the `draft_polli_ratelimit_headers` option is deprecated + * and will be removed in the next major release. + * + * @param draft_polli_ratelimit_headers {any | undefined} - The now-deprecated setting that was used to enable standard headers. + * + * @returns {void} + */ + draftPolliHeaders(draft_polli_ratelimit_headers) { + if (draft_polli_ratelimit_headers) { + throw new ChangeWarning( + "WRN_ERL_DEPRECATED_DRAFT_POLLI_HEADERS", + `The draft_polli_ratelimit_headers configuration option is deprecated and has been removed in express-rate-limit v7, please set standardHeaders: 'draft-6' instead.` + ); + } + }, + /** + * Warns the user that the `onLimitReached` option is deprecated and + * will be removed in the next major release. + * + * @param onLimitReached {any | undefined} - The maximum number of hits per client. + * + * @returns {void} + */ + onLimitReached(onLimitReached) { + if (onLimitReached) { + throw new ChangeWarning( + "WRN_ERL_DEPRECATED_ON_LIMIT_REACHED", + "The onLimitReached configuration option is deprecated and has been removed in express-rate-limit v7." + ); + } + }, + /** + * Warns the user when an invalid/unsupported version of the draft spec is passed. + * + * @param version {any | undefined} - The version passed by the user. + * + * @returns {void} + */ + headersDraftVersion(version) { + if (typeof version !== "string" || // @ts-expect-error This is fine. If version is not in the array, it will just return false. + !SUPPORTED_DRAFT_VERSIONS.includes(version)) { + const versionString = SUPPORTED_DRAFT_VERSIONS.join(", "); + throw new ValidationError( + "ERR_ERL_HEADERS_UNSUPPORTED_DRAFT_VERSION", + `standardHeaders: only the following versions of the IETF draft specification are supported: ${versionString}.` + ); + } + }, + /** + * Warns the user when the selected headers option requires a reset time but + * the store does not provide one. + * + * @param resetTime {Date | undefined} - The timestamp when the client's hit count will be reset. + * + * @returns {void} + */ + headersResetTime(resetTime) { + if (!resetTime) { + throw new ValidationError( + "ERR_ERL_HEADERS_NO_RESET", + `standardHeaders: 'draft-7' requires a 'resetTime', but the store did not provide one. The 'windowMs' value will be used instead, which may cause clients to wait longer than necessary.` + ); + } + }, + knownOptions(passedOptions) { + if (!passedOptions) return; + const optionsMap = { + windowMs: true, + limit: true, + message: true, + statusCode: true, + legacyHeaders: true, + standardHeaders: true, + identifier: true, + requestPropertyName: true, + skipFailedRequests: true, + skipSuccessfulRequests: true, + keyGenerator: true, + ipv6Subnet: true, + handler: true, + skip: true, + requestWasSuccessful: true, + store: true, + validate: true, + headers: true, + max: true, + passOnStoreError: true, + logger: true + }; + const validOptions = Object.keys(optionsMap).concat( + "draft_polli_ratelimit_headers", + // not a valid option anymore, but we have a more specific check for this one, so don't warn for it here + // from express-slow-down - https://github.com/express-rate-limit/express-slow-down/blob/main/source/types.ts#L65 + "delayAfter", + "delayMs", + "maxDelayMs" + ); + for (const key of Object.keys(passedOptions)) { + if (!validOptions.includes(key)) { + throw new ValidationError( + "ERR_ERL_UNKNOWN_OPTION", + `Unexpected configuration option: ${key}` + // todo: suggest a valid option with a short levenstein distance? + ); + } + } + }, + /** + * Checks the options.validate setting to ensure that only recognized + * validations are enabled or disabled. + * + * If any unrecognized values are found, an error is logged that + * includes the list of supported validations. + */ + validationsConfig() { + const supportedValidations = Object.keys(this).filter( + (k) => !["enabled", "disable"].includes(k) + ); + supportedValidations.push("default"); + for (const key of Object.keys(this.enabled)) { + if (!supportedValidations.includes(key)) { + throw new ValidationError( + "ERR_ERL_UNKNOWN_VALIDATION", + `options.validate.${key} is not recognized. Supported validate options are: ${supportedValidations.join( + ", " + )}.` + ); + } + } + }, + /** + * Checks to see if the instance was created inside of a request handler, + * which would prevent it from working correctly, with the default memory + * store (or any other store with localKeys.) + */ + creationStack(store) { + const { stack } = new Error( + "express-rate-limit validation check (set options.validate.creationStack=false to disable)" + ); + if (stack?.includes("Layer.handle [as handle_request]") || // express v4 + stack?.includes("Layer.handleRequest")) { + if (!store.localKeys) { + throw new ValidationError( + "ERR_ERL_CREATED_IN_REQUEST_HANDLER", + "express-rate-limit instance should *usually* be created at app initialization, not when responding to a request." + ); + } + throw new ValidationError( + "ERR_ERL_CREATED_IN_REQUEST_HANDLER", + "express-rate-limit instance should be created at app initialization, not when responding to a request." + ); + } + }, + ipv6Subnet(ipv6Subnet) { + if (ipv6Subnet === false) { + return; + } + if (!Number.isInteger(ipv6Subnet) || ipv6Subnet < 32 || ipv6Subnet > 64) { + throw new ValidationError( + "ERR_ERL_IPV6_SUBNET", + `Unexpected ipv6Subnet value: ${ipv6Subnet}. Expected an integer between 32 and 64 (usually 48-64).` + ); + } + }, + ipv6SubnetOrKeyGenerator(options) { + if (options.ipv6Subnet !== void 0 && options.keyGenerator) { + throw new ValidationError( + "ERR_ERL_IPV6SUBNET_OR_KEYGENERATOR", + `Incompatible options: the 'ipv6Subnet' option is ignored when a custom 'keyGenerator' function is also set.` + ); + } + }, + keyGeneratorIpFallback(keyGenerator) { + if (!keyGenerator) { + return; + } + const src = keyGenerator.toString(); + if ((src.includes("req.ip") || src.includes("request.ip")) && !src.includes("ipKeyGenerator")) { + throw new ValidationError( + "ERR_ERL_KEY_GEN_IPV6", + "Custom keyGenerator appears to use request IP without calling the ipKeyGenerator helper function for IPv6 addresses. This could allow IPv6 users to bypass limits." + ); + } + }, + /** + * Checks to see if the window duration is greater than 2^32 - 1. This is only + * called by the default MemoryStore, since it uses Node's setInterval method. + * + * See https://nodejs.org/api/timers.html#setintervalcallback-delay-args. + */ + windowMs(windowMs) { + const SET_TIMEOUT_MAX = 2 ** 31 - 1; + if (typeof windowMs !== "number" || Number.isNaN(windowMs) || windowMs < 1 || windowMs > SET_TIMEOUT_MAX) { + throw new ValidationError( + "ERR_ERL_WINDOW_MS", + `Invalid windowMs value: ${windowMs}${typeof windowMs !== "number" ? ` (${typeof windowMs})` : ""}, must be a number between 1 and ${SET_TIMEOUT_MAX} when using the default MemoryStore` + ); + } + } +}; +function validateLogger(logger) { + if (typeof logger !== "object" || typeof logger.error !== "function" || typeof logger.warn !== "function") { + throw new TypeError( + "Provided logger does not implement the Logger interface" + ); + } +} +var getValidations = (_enabled, logger) => { + validateLogger(logger); + let enabled; + if (typeof _enabled === "boolean") { + enabled = { + default: _enabled + }; + } else { + enabled = { + default: true, + ..._enabled + }; + } + const wrappedValidations = { enabled }; + for (const [name, validation] of Object.entries(validations)) { + if (typeof validation === "function") + wrappedValidations[name] = (...args) => { + if (!(enabled[name] ?? enabled.default)) { + return; + } + try { + ; + validation.apply( + wrappedValidations, + args + ); + } catch (error) { + if (error instanceof ChangeWarning) logger.warn(error); + else logger.error(error); + } + }; + } + return wrappedValidations; +}; + +// source/rate-limit.ts +var isLegacyStore = (store) => ( + // Check that `incr` exists but `increment` does not - store authors might want + // to keep both around for backwards compatibility. + typeof store.incr === "function" && typeof store.increment !== "function" +); +var promisifyStore = (passedStore) => { + if (!isLegacyStore(passedStore)) { + return passedStore; + } + const legacyStore = passedStore; + class PromisifiedStore { + async increment(key) { + return new Promise((resolve, reject) => { + legacyStore.incr( + key, + (error, totalHits, resetTime) => { + if (error) reject(error); + resolve({ totalHits, resetTime }); + } + ); + }); + } + async decrement(key) { + return legacyStore.decrement(key); + } + async resetKey(key) { + return legacyStore.resetKey(key); + } + /* istanbul ignore next */ + async resetAll() { + if (typeof legacyStore.resetAll === "function") + return legacyStore.resetAll(); + } + } + return new PromisifiedStore(); +}; +var getOptionsFromConfig = (config) => { + const { validations: validations2, ...directlyPassableEntries } = config; + return { + ...directlyPassableEntries, + validate: validations2.enabled + }; +}; +var parseOptions = (passedOptions) => { + const notUndefinedOptions = omitUndefinedProperties(passedOptions); + const logger = passedOptions.logger ?? ConsoleLogger; + const validations2 = getValidations( + notUndefinedOptions?.validate ?? true, + logger + ); + validations2.validationsConfig(); + validations2.knownOptions(passedOptions); + validations2.draftPolliHeaders( + // @ts-expect-error see the note above. + notUndefinedOptions.draft_polli_ratelimit_headers + ); + validations2.onLimitReached(notUndefinedOptions.onLimitReached); + if (notUndefinedOptions.ipv6Subnet !== void 0 && typeof notUndefinedOptions.ipv6Subnet !== "function") { + validations2.ipv6Subnet(notUndefinedOptions.ipv6Subnet); + } + validations2.keyGeneratorIpFallback(notUndefinedOptions.keyGenerator); + validations2.ipv6SubnetOrKeyGenerator(notUndefinedOptions); + let standardHeaders = notUndefinedOptions.standardHeaders ?? false; + if (standardHeaders === true) standardHeaders = "draft-6"; + const config = { + windowMs: 60 * 1e3, + limit: passedOptions.max ?? 5, + // `max` is deprecated, but support it anyways. + message: "Too many requests, please try again later.", + statusCode: 429, + legacyHeaders: passedOptions.headers ?? true, + identifier(request, _response) { + let duration = ""; + const property = config.requestPropertyName; + const { limit } = request[property]; + const seconds = config.windowMs / 1e3; + const minutes = config.windowMs / (1e3 * 60); + const hours = config.windowMs / (1e3 * 60 * 60); + const days = config.windowMs / (1e3 * 60 * 60 * 24); + if (seconds < 60) duration = `${seconds}sec`; + else if (minutes < 60) duration = `${minutes}min`; + else if (hours < 24) duration = `${hours}hr${hours > 1 ? "s" : ""}`; + else duration = `${days}day${days > 1 ? "s" : ""}`; + return `${limit}-in-${duration}`; + }, + requestPropertyName: "rateLimit", + skipFailedRequests: false, + skipSuccessfulRequests: false, + requestWasSuccessful: (_request, response) => response.statusCode < 400, + skip: (_request, _response) => false, + async keyGenerator(request, response) { + validations2.ip(request.ip); + validations2.trustProxy(request); + validations2.xForwardedForHeader(request); + validations2.forwardedHeader(request); + const ip = request.ip; + let subnet = 56; + if ((0, import_node_net3.isIPv6)(ip)) { + subnet = typeof config.ipv6Subnet === "function" ? await config.ipv6Subnet(request, response) : config.ipv6Subnet; + if (typeof config.ipv6Subnet === "function") + validations2.ipv6Subnet(subnet); + } + return ipKeyGenerator(ip, subnet); + }, + ipv6Subnet: 56, + async handler(request, response, _next, _optionsUsed) { + response.status(config.statusCode); + const message = typeof config.message === "function" ? await config.message( + request, + response + ) : config.message; + if (!response.writableEnded) response.send(message); + }, + passOnStoreError: false, + // Allow the default options to be overridden by the passed options. + ...notUndefinedOptions, + // `standardHeaders` is resolved into a draft version above, use that. + standardHeaders, + // Note that this field is declared after the user's options are spread in, + // so that this field doesn't get overridden with an un-promisified store! + store: promisifyStore( + notUndefinedOptions.store ?? new MemoryStore(validations2) + ), + // Print an error to the console if a few known misconfigurations are detected. + validations: validations2, + logger + }; + if (typeof config.store.increment !== "function" || typeof config.store.decrement !== "function" || typeof config.store.resetKey !== "function" || config.store.resetAll !== void 0 && typeof config.store.resetAll !== "function" || config.store.init !== void 0 && typeof config.store.init !== "function") { + throw new TypeError( + "An invalid store was passed. Please ensure that the store is a class that implements the `Store` interface." + ); + } + return config; +}; +var handleAsyncErrors = (fn) => async (request, response, next) => { + try { + await Promise.resolve(fn(request, response, next)).catch(next); + } catch (error) { + next(error); + } +}; +var rateLimit = (passedOptions) => { + const config = parseOptions(passedOptions ?? {}); + const options = getOptionsFromConfig(config); + config.validations.creationStack(config.store); + config.validations.unsharedStore(config.store); + if (typeof config.store.init === "function") { + try { + const storeInit = config.store.init(options); + if (storeInit instanceof Promise) { + storeInit.catch( + (error) => config.logger.error( + error, + "express-rate-limit: async error during store initialization." + ) + ); + } + } catch (error) { + config.logger.error( + error, + "express-rate-limit: error during store initialization." + ); + } + } + const middleware = handleAsyncErrors( + async (request, response, next) => { + const closePromise = config.skipFailedRequests && new Promise((resolve) => response.once("close", resolve)); + const finishPromise = (config.skipFailedRequests || config.skipSuccessfulRequests) && new Promise((resolve) => response.once("finish", resolve)); + const errorPromise = config.skipFailedRequests && new Promise((resolve) => response.once("error", resolve)); + const skip = await config.skip(request, response); + if (skip) { + next(); + return; + } + const augmentedRequest = request; + const key = await config.keyGenerator(request, response); + let totalHits = 0; + let resetTime; + try { + const incrementResult = await config.store.increment(key); + totalHits = incrementResult.totalHits; + resetTime = incrementResult.resetTime; + } catch (error) { + if (config.passOnStoreError) { + config.logger.error( + error, + "express-rate-limit: error from store, allowing request without rate-limiting." + ); + next(); + return; + } + throw error; + } + config.validations.positiveHits(totalHits); + config.validations.singleCount(request, config.store, key); + const retrieveLimit = typeof config.limit === "function" ? config.limit(request, response) : config.limit; + const limit = await retrieveLimit; + config.validations.limit(limit); + const info = { + limit, + used: totalHits, + remaining: Math.max(limit - totalHits, 0), + resetTime, + key + }; + Object.defineProperty(info, "current", { + configurable: false, + enumerable: false, + value: totalHits + }); + augmentedRequest[config.requestPropertyName] = info; + if (config.legacyHeaders && !response.headersSent) { + setLegacyHeaders(response, info); + } + if (config.standardHeaders && !response.headersSent) { + switch (config.standardHeaders) { + case "draft-6": { + setDraft6Headers(response, info, config.windowMs); + break; + } + case "draft-7": { + config.validations.headersResetTime(info.resetTime); + setDraft7Headers(response, info, config.windowMs); + break; + } + case "draft-8": { + const retrieveName = typeof config.identifier === "function" ? config.identifier(request, response) : config.identifier; + const name = await retrieveName; + config.validations.headersResetTime(info.resetTime); + setDraft8Headers(response, info, config.windowMs, name, key); + break; + } + default: { + config.validations.headersDraftVersion(config.standardHeaders); + break; + } + } + } + if (config.skipFailedRequests || config.skipSuccessfulRequests) { + let decremented = false; + const decrementKey = async () => { + if (!decremented) { + await config.store.decrement(key); + decremented = true; + } + }; + if (config.skipFailedRequests) { + if (finishPromise) { + void finishPromise.then(async () => { + if (!await config.requestWasSuccessful(request, response)) + await decrementKey(); + }); + } + if (closePromise) { + void closePromise.then(async () => { + if (!response.writableEnded) await decrementKey(); + }); + } + if (errorPromise) { + void errorPromise.then(async () => { + await decrementKey(); + }); + } + } + if (config.skipSuccessfulRequests) { + if (finishPromise) { + void finishPromise.then(async () => { + if (await config.requestWasSuccessful(request, response)) + await decrementKey(); + }); + } + } + } + config.validations.disable(); + if (totalHits > limit) { + if (config.legacyHeaders || config.standardHeaders) { + setRetryAfterHeader(response, info, config.windowMs); + } + config.handler(request, response, next, options); + return; + } + next(); + } + ); + const getThrowFn = () => { + throw new Error("The current store does not support the get/getKey method"); + }; + middleware.resetKey = config.store.resetKey.bind(config.store); + middleware.getKey = typeof config.store.get === "function" ? config.store.get.bind(config.store) : getThrowFn; + return middleware; +}; +var rate_limit_default = rateLimit; +// Annotate the CommonJS export names for ESM import in node: +0 && (module.exports = { + MemoryStore, + ipKeyGenerator, + rateLimit +}); +module.exports = Object.assign(rateLimit, module.exports); diff --git a/tools/ui/node_modules/express-rate-limit/dist/index.d.cts b/tools/ui/node_modules/express-rate-limit/dist/index.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..c93d9244e5e4c56e8e9e90accfe28e11599c8447 --- /dev/null +++ b/tools/ui/node_modules/express-rate-limit/dist/index.d.cts @@ -0,0 +1,672 @@ +// Generated by dts-bundle-generator v8.1.2 + +import { NextFunction, Request, RequestHandler, Response } from 'express'; + +/** + * Returns the IP address itself for IPv4, or a CIDR-notation subnet for IPv6. + * + * If you write a custom keyGenerator that allows a fallback to IP address for + * unauthenticated users, return ipKeyGenerator(req.ip) rather than just req.ip. + * + * For more information, {@see Options.ipv6Subnet}. + * + * @param ip {string} - The IP address to process, usually request.ip. + * @param ipv6Subnet {number | false} - The subnet mask for IPv6 addresses. + * + * @returns {string} - The key generated from the IP address + * + * @public + */ +export declare function ipKeyGenerator(ip: string, ipv6Subnet?: number | false): string; +declare const SUPPORTED_DRAFT_VERSIONS: readonly [ + "draft-6", + "draft-7", + "draft-8" +]; +declare const validations: { + enabled: { + [key: string]: boolean; + }; + disable(): void; + /** + * Checks whether the IP address is valid, and that it does not have a port + * number in it. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_invalid_ip_address. + * + * @param ip {string | undefined} - The IP address provided by Express as request.ip. + * + * @returns {void} + */ + ip(ip: string | undefined): void; + /** + * Makes sure the trust proxy setting is not set to `true`. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_permissive_trust_proxy. + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + trustProxy(request: Request): void; + /** + * Makes sure the trust proxy setting is set in case the `X-Forwarded-For` + * header is present. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_unset_trust_proxy. + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + xForwardedForHeader(request: Request): void; + /** + * Alert the user if the Forwarded header is set (standardized version of X-Forwarded-For - not supported by express as of version 5.1.0) + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + forwardedHeader(request: Request): void; + /** + * Ensures totalHits value from store is a positive integer. + * + * @param hits {any} - The `totalHits` returned by the store. + */ + positiveHits(hits: any): void; + /** + * Ensures a single store instance is not used with multiple express-rate-limit instances + */ + unsharedStore(store: Store): void; + /** + * Ensures a given key is incremented only once per request. + * + * @param request {Request} - The Express request object. + * @param store {Store} - The store class. + * @param key {string} - The key used to store the client's hit count. + * + * @returns {void} + */ + singleCount(request: Request, store: Store, key: string): void; + /** + * Warns the user that the behaviour for `max: 0` / `limit: 0` is + * changing in the next major release. + * + * @param limit {number} - The maximum number of hits per client. + * + * @returns {void} + */ + limit(limit: number): void; + /** + * Warns the user that the `draft_polli_ratelimit_headers` option is deprecated + * and will be removed in the next major release. + * + * @param draft_polli_ratelimit_headers {any | undefined} - The now-deprecated setting that was used to enable standard headers. + * + * @returns {void} + */ + draftPolliHeaders(draft_polli_ratelimit_headers?: any): void; + /** + * Warns the user that the `onLimitReached` option is deprecated and + * will be removed in the next major release. + * + * @param onLimitReached {any | undefined} - The maximum number of hits per client. + * + * @returns {void} + */ + onLimitReached(onLimitReached?: any): void; + /** + * Warns the user when an invalid/unsupported version of the draft spec is passed. + * + * @param version {any | undefined} - The version passed by the user. + * + * @returns {void} + */ + headersDraftVersion(version?: any): void; + /** + * Warns the user when the selected headers option requires a reset time but + * the store does not provide one. + * + * @param resetTime {Date | undefined} - The timestamp when the client's hit count will be reset. + * + * @returns {void} + */ + headersResetTime(resetTime?: Date): void; + knownOptions(passedOptions?: Partial): void; + /** + * Checks the options.validate setting to ensure that only recognized + * validations are enabled or disabled. + * + * If any unrecognized values are found, an error is logged that + * includes the list of supported validations. + */ + validationsConfig(): void; + /** + * Checks to see if the instance was created inside of a request handler, + * which would prevent it from working correctly, with the default memory + * store (or any other store with localKeys.) + */ + creationStack(store: Store): void; + ipv6Subnet(ipv6Subnet?: any): void; + ipv6SubnetOrKeyGenerator(options: Partial): void; + keyGeneratorIpFallback(keyGenerator?: ValueDeterminingMiddleware): void; + /** + * Checks to see if the window duration is greater than 2^32 - 1. This is only + * called by the default MemoryStore, since it uses Node's setInterval method. + * + * See https://nodejs.org/api/timers.html#setintervalcallback-delay-args. + */ + windowMs(windowMs: number): void; +}; +export type Validations = typeof validations; +/** + * Basic logging function + * + * @param error {unknown} - The error to log + * @param message {string | undefined} - Additional details about the error + */ +export type LoggerFn = (error: unknown, message?: string) => void; +/** + * Minimal interface for logging warnings and errors + */ +export type Logger = { + /** + * Function to log an error + */ + error: LoggerFn; + /** + * Function to log a warning + */ + warn: LoggerFn; +}; +/** + * Callback that fires when a client's hit counter is incremented. + * + * @param error {Error | undefined} - The error that occurred, if any. + * @param totalHits {number} - The number of hits for that client so far. + * @param resetTime {Date | undefined} - The time when the counter resets. + */ +export type IncrementCallback = (error: Error | undefined, totalHits: number, resetTime: Date | undefined) => void; +/** + * Method (in the form of middleware) to generate/retrieve a value based on the + * incoming request. + * + * @param request {Request} - The Express request object. + * @param response {Response} - The Express response object. + * + * @returns {T} - The value needed. + */ +export type ValueDeterminingMiddleware = (request: Request, response: Response) => T | Promise; +/** + * Express request handler that sends back a response when a client is + * rate-limited. + * + * @param request {Request} - The Express request object. + * @param response {Response} - The Express response object. + * @param next {NextFunction} - The Express `next` function, can be called to skip responding. + * @param optionsUsed {Options} - The options used to set up the middleware. + */ +export type RateLimitExceededEventHandler = (request: Request, response: Response, next: NextFunction, optionsUsed: Options) => void; +/** + * Event callback that is triggered on a client's first request that exceeds the limit + * but not for subsequent requests. May be used for logging, etc. Should *not* + * send a response. + * + * @param request {Request} - The Express request object. + * @param response {Response} - The Express response object. + * @param optionsUsed {Options} - The options used to set up the middleware. + */ +export type RateLimitReachedEventHandler = (request: Request, response: Response, optionsUsed: Options) => void; +/** + * Data returned from the `Store` when a client's hit counter is incremented. + * + * @property totalHits {number} - The number of hits for that client so far. + * @property resetTime {Date | undefined} - The time when the counter resets. + */ +export type ClientRateLimitInfo = { + totalHits: number; + resetTime: Date | undefined; +}; +export type IncrementResponse = ClientRateLimitInfo; +/** + * A modified Express request handler with the rate limit functions. + */ +export type RateLimitRequestHandler = RequestHandler & { + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + resetKey: (key: string) => void; + /** + * Method to fetch a client's hit count and reset time. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client. + */ + getKey: (key: string) => Promise | ClientRateLimitInfo | undefined; +}; +/** + * An interface that all hit counter stores must implement. + * + * @deprecated 6.x - Implement the `Store` interface instead. + */ +export type LegacyStore = { + /** + * Method to increment a client's hit counter. + * + * @param key {string} - The identifier for a client. + * @param callback {IncrementCallback} - The callback to call once the counter is incremented. + */ + incr: (key: string, callback: IncrementCallback) => void; + /** + * Method to decrement a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + decrement: (key: string) => void; + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + resetKey: (key: string) => void; + /** + * Method to reset everyone's hit counter. + */ + resetAll?: () => void; +}; +/** + * An interface that all hit counter stores must implement. + */ +export type Store = { + /** + * Method that initializes the store, and has access to the options passed to + * the middleware too. + * + * Called once during initialization. + * + * Errors / promise rejections will be caught and logged. + * + * Note that the result is not awaited - other store methods (such as increment) may be called before init returns and/or after it throws/rejects. + * + * @param options {Options} - The options used to setup the middleware. + */ + init?: (options: Options) => void | Promise; + /** + * Method to fetch a client's hit count and reset time. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client. + */ + get?: (key: string) => Promise | ClientRateLimitInfo | undefined; + /** + * Method to increment a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @returns {IncrementResponse | undefined} - The number of hits and reset time for that client. + */ + increment: (key: string) => Promise | IncrementResponse; + /** + * Method to decrement a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + decrement: (key: string) => Promise | void; + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + resetKey: (key: string) => Promise | void; + /** + * Method to reset everyone's hit counter. + */ + resetAll?: () => Promise | void; + /** + * Method to shutdown the store, stop timers, and release all resources. + */ + shutdown?: () => Promise | void; + /** + * Flag to indicate that keys incremented in one instance of this store can + * not affect other instances. Typically false if a database is used, true for + * MemoryStore. + * + * Used to help detect double-counting misconfigurations. + */ + localKeys?: boolean; + /** + * Optional value that the store prepends to keys + * + * Used by the double-count check to avoid false-positives when a key is counted + * twice, but with different prefixes. + */ + prefix?: string; +}; +export type DraftHeadersVersion = (typeof SUPPORTED_DRAFT_VERSIONS)[number]; +/** + * Validate configuration object for enabling or disabling specific validations. + * + * The keys must also be keys in the validations object, except `enable`, `disable`, + * and `default`. + */ +export type EnabledValidations = { + [key in keyof Omit | "default"]?: boolean; +}; +/** + * The configuration options for the rate limiter. + */ +export type Options = { + /** + * How long we should remember the requests. + * + * Defaults to `60000` ms (= 1 minute). + */ + windowMs: number; + /** + * The maximum number of connections to allow during the `window` before + * rate limiting the client. + * + * Can be the limit itself as a number or express middleware that parses + * the request and then figures out the limit. + * + * Defaults to `5`. + */ + limit: number | ValueDeterminingMiddleware; + /** + * The response body to send back when a client is rate limited. + * + * Defaults to `'Too many requests, please try again later.'` + */ + message: any | ValueDeterminingMiddleware; + /** + * The HTTP status code to send back when a client is rate limited. + * + * Defaults to `HTTP 429 Too Many Requests` (RFC 6585). + */ + statusCode: number; + /** + * Whether to send `X-RateLimit-*` headers with the rate limit and the number + * of requests. + * + * Defaults to `true` (for backward compatibility). + */ + legacyHeaders: boolean; + /** + * Whether to enable support for the standardized rate limit headers (`RateLimit-*`). + * + * Defaults to `false` (for backward compatibility, but its use is recommended). + */ + standardHeaders: boolean | DraftHeadersVersion; + /** + * The name used to identify the quota policy in the `RateLimit` headers as per + * the 8th draft of the IETF specification. + * + * Defaults to `{limit}-in-{window}`. + */ + identifier: string | ValueDeterminingMiddleware; + /** + * The name of the property on the request object to store the rate limit info. + * + * Defaults to `rateLimit`. + */ + requestPropertyName: string; + /** + * If `true`, the library will (by default) skip all requests that have a 4XX + * or 5XX status. + * + * Defaults to `false`. + */ + skipFailedRequests: boolean; + /** + * If `true`, the library will (by default) skip all requests that have a + * status code less than 400. + * + * Defaults to `false`. + */ + skipSuccessfulRequests: boolean; + /** + * Method to generate custom identifiers for clients. + * + * By default, the client's IP address is used. + */ + keyGenerator: ValueDeterminingMiddleware; + /** + * IPv6 subnet mask applied to IPv6 addresses in the default keyGenerator. + * + * Default is 56. The valid range is technically 1-128 but the value should + * generally be in the 32-64 range. + * + * Smaller numbers are more aggressive, larger numbers are more lenient. Try + * bumping to 60 or 64 if you see evidence of users being blocked incorrectly. + * + * May also be set to a function that returns a number based on the request. + * + * See the documentation for more info: + * https://express-rate-limit.mintlify.app/reference/configuration#ipv6subnet. + */ + ipv6Subnet: 64 | 60 | 56 | 52 | 50 | 48 | 32 | number | ValueDeterminingMiddleware | false; + /** + * Express request handler that sends back a response when a client is + * rate-limited. + * + * By default, sends back the `statusCode` and `message` set via the options. + */ + handler: RateLimitExceededEventHandler; + /** + * Method (in the form of middleware) to determine whether or not this request + * counts towards a client's quota. + * + * By default, skips no requests. + */ + skip: ValueDeterminingMiddleware; + /** + * Method to determine whether or not the request counts as 'successful'. Used + * when either `skipSuccessfulRequests` or `skipFailedRequests` is set to true. + * + * By default, requests with a response status code less than 400 are considered + * successful. + */ + requestWasSuccessful: ValueDeterminingMiddleware; + /** + * The `Store` to use to store the hit count for each client. + * + * By default, the built-in `MemoryStore` will be used. + */ + store: Store | LegacyStore; + /** + * The list of validation checks that should run. + */ + validate: boolean | EnabledValidations; + /** + * Whether to send `X-RateLimit-*` headers with the rate limit and the number + * of requests. + * + * @deprecated 6.x - This option was renamed to `legacyHeaders`. + */ + headers?: boolean; + /** + * The maximum number of connections to allow during the `window` before + * rate limiting the client. + * + * Can be the limit itself as a number or express middleware that parses + * the request and then figures out the limit. + * + * @deprecated 7.x - This option was renamed to `limit`. However, it will not + * be removed from the library in the foreseeable future. + */ + max?: number | ValueDeterminingMiddleware; + /** + * If the Store generates an error, allow the request to pass. + */ + passOnStoreError: boolean; + /** + * The logger to use to log errors. If absent, logs to the console. + */ + logger: Logger; +}; +/** + * The extended request object that includes information about the client's + * rate limit. + */ +export type AugmentedRequest = Request & { + [key: string]: RateLimitInfo; +}; +/** + * The rate limit related information for each client included in the + * Express request object. + */ +export type RateLimitInfo = { + limit: number; + used: number; + remaining: number; + resetTime: Date | undefined; + key: string; +}; +/** + * The record that stores information about a client - namely, how many times + * they have hit the endpoint, and when their hit count resets. + * + * Similar to `ClientRateLimitInfo`, except `resetTime` is a compulsory field. + */ +export type Client = { + totalHits: number; + resetTime: Date; +}; +/** + * A `Store` that stores the hit count for each client in memory. + * + * @public + */ +export declare class MemoryStore implements Store { + private validations?; + /** + * The duration of time before which all hit counts are reset (in milliseconds). + */ + windowMs: number; + /** + * These two maps store usage (requests) and reset time by key (for example, IP + * addresses or API keys). + * + * They are split into two to avoid having to iterate through the entire set to + * determine which ones need reset. Instead, `Client`s are moved from `previous` + * to `current` as they hit the endpoint. Once `windowMs` has elapsed, all clients + * left in `previous`, i.e., those that have not made any recent requests, are + * known to be expired and can be deleted in bulk. + */ + previous: Map; + current: Map; + /** + * A reference to the active timer. + */ + interval?: NodeJS.Timeout; + /** + * Confirmation that the keys incremented in once instance of MemoryStore + * cannot affect other instances. + */ + localKeys: boolean; + constructor(validations?: Validations | undefined); + /** + * Method that initializes the store. + * + * @param options {Options} - The options used to setup the middleware. + */ + init(options: Options): void; + /** + * Method to fetch a client's hit count and reset time. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo | undefined} - The number of hits and reset time for that client. + * + * @public + */ + get(key: string): Promise; + /** + * Method to increment a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client. + * + * @public + */ + increment(key: string): Promise; + /** + * Method to decrement a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @public + */ + decrement(key: string): Promise; + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @public + */ + resetKey(key: string): Promise; + /** + * Method to reset everyone's hit counter. + * + * @public + */ + resetAll(): Promise; + /** + * Method to stop the timer (if currently running) and prevent any memory + * leaks. + * + * @public + */ + shutdown(): void; + /** + * Recycles a client by setting its hit count to zero, and reset time to + * `windowMs` milliseconds from now. + * + * NOT to be confused with `#resetKey()`, which removes a client from both the + * `current` and `previous` maps. + * + * @param client {Client} - The client to recycle. + * @param now {number} - The current time, to which the `windowMs` is added to get the `resetTime` for the client. + * + * @return {Client} - The modified client that was passed in, to allow for chaining. + */ + private resetClient; + /** + * Retrieves or creates a client, given a key. Also ensures that the client being + * returned is in the `current` map. + * + * @param key {string} - The key under which the client is (or is to be) stored. + * + * @returns {Client} - The requested client. + */ + private getClient; + /** + * Move current clients to previous, create a new map for current. + * + * This function is called every `windowMs`. + */ + private clearExpired; +} +/** + * + * Create an instance of IP rate-limiting middleware for Express. + * + * @param passedOptions {Options} - Options to configure the rate limiter. + * + * @returns {RateLimitRequestHandler} - The middleware that rate-limits clients based on your configuration. + * + * @public + */ +export declare const rateLimit: (passedOptions?: Partial) => RateLimitRequestHandler; + +export { + rateLimit as default, +}; + +export {}; diff --git a/tools/ui/node_modules/express-rate-limit/dist/index.d.mts b/tools/ui/node_modules/express-rate-limit/dist/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..c93d9244e5e4c56e8e9e90accfe28e11599c8447 --- /dev/null +++ b/tools/ui/node_modules/express-rate-limit/dist/index.d.mts @@ -0,0 +1,672 @@ +// Generated by dts-bundle-generator v8.1.2 + +import { NextFunction, Request, RequestHandler, Response } from 'express'; + +/** + * Returns the IP address itself for IPv4, or a CIDR-notation subnet for IPv6. + * + * If you write a custom keyGenerator that allows a fallback to IP address for + * unauthenticated users, return ipKeyGenerator(req.ip) rather than just req.ip. + * + * For more information, {@see Options.ipv6Subnet}. + * + * @param ip {string} - The IP address to process, usually request.ip. + * @param ipv6Subnet {number | false} - The subnet mask for IPv6 addresses. + * + * @returns {string} - The key generated from the IP address + * + * @public + */ +export declare function ipKeyGenerator(ip: string, ipv6Subnet?: number | false): string; +declare const SUPPORTED_DRAFT_VERSIONS: readonly [ + "draft-6", + "draft-7", + "draft-8" +]; +declare const validations: { + enabled: { + [key: string]: boolean; + }; + disable(): void; + /** + * Checks whether the IP address is valid, and that it does not have a port + * number in it. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_invalid_ip_address. + * + * @param ip {string | undefined} - The IP address provided by Express as request.ip. + * + * @returns {void} + */ + ip(ip: string | undefined): void; + /** + * Makes sure the trust proxy setting is not set to `true`. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_permissive_trust_proxy. + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + trustProxy(request: Request): void; + /** + * Makes sure the trust proxy setting is set in case the `X-Forwarded-For` + * header is present. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_unset_trust_proxy. + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + xForwardedForHeader(request: Request): void; + /** + * Alert the user if the Forwarded header is set (standardized version of X-Forwarded-For - not supported by express as of version 5.1.0) + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + forwardedHeader(request: Request): void; + /** + * Ensures totalHits value from store is a positive integer. + * + * @param hits {any} - The `totalHits` returned by the store. + */ + positiveHits(hits: any): void; + /** + * Ensures a single store instance is not used with multiple express-rate-limit instances + */ + unsharedStore(store: Store): void; + /** + * Ensures a given key is incremented only once per request. + * + * @param request {Request} - The Express request object. + * @param store {Store} - The store class. + * @param key {string} - The key used to store the client's hit count. + * + * @returns {void} + */ + singleCount(request: Request, store: Store, key: string): void; + /** + * Warns the user that the behaviour for `max: 0` / `limit: 0` is + * changing in the next major release. + * + * @param limit {number} - The maximum number of hits per client. + * + * @returns {void} + */ + limit(limit: number): void; + /** + * Warns the user that the `draft_polli_ratelimit_headers` option is deprecated + * and will be removed in the next major release. + * + * @param draft_polli_ratelimit_headers {any | undefined} - The now-deprecated setting that was used to enable standard headers. + * + * @returns {void} + */ + draftPolliHeaders(draft_polli_ratelimit_headers?: any): void; + /** + * Warns the user that the `onLimitReached` option is deprecated and + * will be removed in the next major release. + * + * @param onLimitReached {any | undefined} - The maximum number of hits per client. + * + * @returns {void} + */ + onLimitReached(onLimitReached?: any): void; + /** + * Warns the user when an invalid/unsupported version of the draft spec is passed. + * + * @param version {any | undefined} - The version passed by the user. + * + * @returns {void} + */ + headersDraftVersion(version?: any): void; + /** + * Warns the user when the selected headers option requires a reset time but + * the store does not provide one. + * + * @param resetTime {Date | undefined} - The timestamp when the client's hit count will be reset. + * + * @returns {void} + */ + headersResetTime(resetTime?: Date): void; + knownOptions(passedOptions?: Partial): void; + /** + * Checks the options.validate setting to ensure that only recognized + * validations are enabled or disabled. + * + * If any unrecognized values are found, an error is logged that + * includes the list of supported validations. + */ + validationsConfig(): void; + /** + * Checks to see if the instance was created inside of a request handler, + * which would prevent it from working correctly, with the default memory + * store (or any other store with localKeys.) + */ + creationStack(store: Store): void; + ipv6Subnet(ipv6Subnet?: any): void; + ipv6SubnetOrKeyGenerator(options: Partial): void; + keyGeneratorIpFallback(keyGenerator?: ValueDeterminingMiddleware): void; + /** + * Checks to see if the window duration is greater than 2^32 - 1. This is only + * called by the default MemoryStore, since it uses Node's setInterval method. + * + * See https://nodejs.org/api/timers.html#setintervalcallback-delay-args. + */ + windowMs(windowMs: number): void; +}; +export type Validations = typeof validations; +/** + * Basic logging function + * + * @param error {unknown} - The error to log + * @param message {string | undefined} - Additional details about the error + */ +export type LoggerFn = (error: unknown, message?: string) => void; +/** + * Minimal interface for logging warnings and errors + */ +export type Logger = { + /** + * Function to log an error + */ + error: LoggerFn; + /** + * Function to log a warning + */ + warn: LoggerFn; +}; +/** + * Callback that fires when a client's hit counter is incremented. + * + * @param error {Error | undefined} - The error that occurred, if any. + * @param totalHits {number} - The number of hits for that client so far. + * @param resetTime {Date | undefined} - The time when the counter resets. + */ +export type IncrementCallback = (error: Error | undefined, totalHits: number, resetTime: Date | undefined) => void; +/** + * Method (in the form of middleware) to generate/retrieve a value based on the + * incoming request. + * + * @param request {Request} - The Express request object. + * @param response {Response} - The Express response object. + * + * @returns {T} - The value needed. + */ +export type ValueDeterminingMiddleware = (request: Request, response: Response) => T | Promise; +/** + * Express request handler that sends back a response when a client is + * rate-limited. + * + * @param request {Request} - The Express request object. + * @param response {Response} - The Express response object. + * @param next {NextFunction} - The Express `next` function, can be called to skip responding. + * @param optionsUsed {Options} - The options used to set up the middleware. + */ +export type RateLimitExceededEventHandler = (request: Request, response: Response, next: NextFunction, optionsUsed: Options) => void; +/** + * Event callback that is triggered on a client's first request that exceeds the limit + * but not for subsequent requests. May be used for logging, etc. Should *not* + * send a response. + * + * @param request {Request} - The Express request object. + * @param response {Response} - The Express response object. + * @param optionsUsed {Options} - The options used to set up the middleware. + */ +export type RateLimitReachedEventHandler = (request: Request, response: Response, optionsUsed: Options) => void; +/** + * Data returned from the `Store` when a client's hit counter is incremented. + * + * @property totalHits {number} - The number of hits for that client so far. + * @property resetTime {Date | undefined} - The time when the counter resets. + */ +export type ClientRateLimitInfo = { + totalHits: number; + resetTime: Date | undefined; +}; +export type IncrementResponse = ClientRateLimitInfo; +/** + * A modified Express request handler with the rate limit functions. + */ +export type RateLimitRequestHandler = RequestHandler & { + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + resetKey: (key: string) => void; + /** + * Method to fetch a client's hit count and reset time. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client. + */ + getKey: (key: string) => Promise | ClientRateLimitInfo | undefined; +}; +/** + * An interface that all hit counter stores must implement. + * + * @deprecated 6.x - Implement the `Store` interface instead. + */ +export type LegacyStore = { + /** + * Method to increment a client's hit counter. + * + * @param key {string} - The identifier for a client. + * @param callback {IncrementCallback} - The callback to call once the counter is incremented. + */ + incr: (key: string, callback: IncrementCallback) => void; + /** + * Method to decrement a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + decrement: (key: string) => void; + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + resetKey: (key: string) => void; + /** + * Method to reset everyone's hit counter. + */ + resetAll?: () => void; +}; +/** + * An interface that all hit counter stores must implement. + */ +export type Store = { + /** + * Method that initializes the store, and has access to the options passed to + * the middleware too. + * + * Called once during initialization. + * + * Errors / promise rejections will be caught and logged. + * + * Note that the result is not awaited - other store methods (such as increment) may be called before init returns and/or after it throws/rejects. + * + * @param options {Options} - The options used to setup the middleware. + */ + init?: (options: Options) => void | Promise; + /** + * Method to fetch a client's hit count and reset time. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client. + */ + get?: (key: string) => Promise | ClientRateLimitInfo | undefined; + /** + * Method to increment a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @returns {IncrementResponse | undefined} - The number of hits and reset time for that client. + */ + increment: (key: string) => Promise | IncrementResponse; + /** + * Method to decrement a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + decrement: (key: string) => Promise | void; + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + resetKey: (key: string) => Promise | void; + /** + * Method to reset everyone's hit counter. + */ + resetAll?: () => Promise | void; + /** + * Method to shutdown the store, stop timers, and release all resources. + */ + shutdown?: () => Promise | void; + /** + * Flag to indicate that keys incremented in one instance of this store can + * not affect other instances. Typically false if a database is used, true for + * MemoryStore. + * + * Used to help detect double-counting misconfigurations. + */ + localKeys?: boolean; + /** + * Optional value that the store prepends to keys + * + * Used by the double-count check to avoid false-positives when a key is counted + * twice, but with different prefixes. + */ + prefix?: string; +}; +export type DraftHeadersVersion = (typeof SUPPORTED_DRAFT_VERSIONS)[number]; +/** + * Validate configuration object for enabling or disabling specific validations. + * + * The keys must also be keys in the validations object, except `enable`, `disable`, + * and `default`. + */ +export type EnabledValidations = { + [key in keyof Omit | "default"]?: boolean; +}; +/** + * The configuration options for the rate limiter. + */ +export type Options = { + /** + * How long we should remember the requests. + * + * Defaults to `60000` ms (= 1 minute). + */ + windowMs: number; + /** + * The maximum number of connections to allow during the `window` before + * rate limiting the client. + * + * Can be the limit itself as a number or express middleware that parses + * the request and then figures out the limit. + * + * Defaults to `5`. + */ + limit: number | ValueDeterminingMiddleware; + /** + * The response body to send back when a client is rate limited. + * + * Defaults to `'Too many requests, please try again later.'` + */ + message: any | ValueDeterminingMiddleware; + /** + * The HTTP status code to send back when a client is rate limited. + * + * Defaults to `HTTP 429 Too Many Requests` (RFC 6585). + */ + statusCode: number; + /** + * Whether to send `X-RateLimit-*` headers with the rate limit and the number + * of requests. + * + * Defaults to `true` (for backward compatibility). + */ + legacyHeaders: boolean; + /** + * Whether to enable support for the standardized rate limit headers (`RateLimit-*`). + * + * Defaults to `false` (for backward compatibility, but its use is recommended). + */ + standardHeaders: boolean | DraftHeadersVersion; + /** + * The name used to identify the quota policy in the `RateLimit` headers as per + * the 8th draft of the IETF specification. + * + * Defaults to `{limit}-in-{window}`. + */ + identifier: string | ValueDeterminingMiddleware; + /** + * The name of the property on the request object to store the rate limit info. + * + * Defaults to `rateLimit`. + */ + requestPropertyName: string; + /** + * If `true`, the library will (by default) skip all requests that have a 4XX + * or 5XX status. + * + * Defaults to `false`. + */ + skipFailedRequests: boolean; + /** + * If `true`, the library will (by default) skip all requests that have a + * status code less than 400. + * + * Defaults to `false`. + */ + skipSuccessfulRequests: boolean; + /** + * Method to generate custom identifiers for clients. + * + * By default, the client's IP address is used. + */ + keyGenerator: ValueDeterminingMiddleware; + /** + * IPv6 subnet mask applied to IPv6 addresses in the default keyGenerator. + * + * Default is 56. The valid range is technically 1-128 but the value should + * generally be in the 32-64 range. + * + * Smaller numbers are more aggressive, larger numbers are more lenient. Try + * bumping to 60 or 64 if you see evidence of users being blocked incorrectly. + * + * May also be set to a function that returns a number based on the request. + * + * See the documentation for more info: + * https://express-rate-limit.mintlify.app/reference/configuration#ipv6subnet. + */ + ipv6Subnet: 64 | 60 | 56 | 52 | 50 | 48 | 32 | number | ValueDeterminingMiddleware | false; + /** + * Express request handler that sends back a response when a client is + * rate-limited. + * + * By default, sends back the `statusCode` and `message` set via the options. + */ + handler: RateLimitExceededEventHandler; + /** + * Method (in the form of middleware) to determine whether or not this request + * counts towards a client's quota. + * + * By default, skips no requests. + */ + skip: ValueDeterminingMiddleware; + /** + * Method to determine whether or not the request counts as 'successful'. Used + * when either `skipSuccessfulRequests` or `skipFailedRequests` is set to true. + * + * By default, requests with a response status code less than 400 are considered + * successful. + */ + requestWasSuccessful: ValueDeterminingMiddleware; + /** + * The `Store` to use to store the hit count for each client. + * + * By default, the built-in `MemoryStore` will be used. + */ + store: Store | LegacyStore; + /** + * The list of validation checks that should run. + */ + validate: boolean | EnabledValidations; + /** + * Whether to send `X-RateLimit-*` headers with the rate limit and the number + * of requests. + * + * @deprecated 6.x - This option was renamed to `legacyHeaders`. + */ + headers?: boolean; + /** + * The maximum number of connections to allow during the `window` before + * rate limiting the client. + * + * Can be the limit itself as a number or express middleware that parses + * the request and then figures out the limit. + * + * @deprecated 7.x - This option was renamed to `limit`. However, it will not + * be removed from the library in the foreseeable future. + */ + max?: number | ValueDeterminingMiddleware; + /** + * If the Store generates an error, allow the request to pass. + */ + passOnStoreError: boolean; + /** + * The logger to use to log errors. If absent, logs to the console. + */ + logger: Logger; +}; +/** + * The extended request object that includes information about the client's + * rate limit. + */ +export type AugmentedRequest = Request & { + [key: string]: RateLimitInfo; +}; +/** + * The rate limit related information for each client included in the + * Express request object. + */ +export type RateLimitInfo = { + limit: number; + used: number; + remaining: number; + resetTime: Date | undefined; + key: string; +}; +/** + * The record that stores information about a client - namely, how many times + * they have hit the endpoint, and when their hit count resets. + * + * Similar to `ClientRateLimitInfo`, except `resetTime` is a compulsory field. + */ +export type Client = { + totalHits: number; + resetTime: Date; +}; +/** + * A `Store` that stores the hit count for each client in memory. + * + * @public + */ +export declare class MemoryStore implements Store { + private validations?; + /** + * The duration of time before which all hit counts are reset (in milliseconds). + */ + windowMs: number; + /** + * These two maps store usage (requests) and reset time by key (for example, IP + * addresses or API keys). + * + * They are split into two to avoid having to iterate through the entire set to + * determine which ones need reset. Instead, `Client`s are moved from `previous` + * to `current` as they hit the endpoint. Once `windowMs` has elapsed, all clients + * left in `previous`, i.e., those that have not made any recent requests, are + * known to be expired and can be deleted in bulk. + */ + previous: Map; + current: Map; + /** + * A reference to the active timer. + */ + interval?: NodeJS.Timeout; + /** + * Confirmation that the keys incremented in once instance of MemoryStore + * cannot affect other instances. + */ + localKeys: boolean; + constructor(validations?: Validations | undefined); + /** + * Method that initializes the store. + * + * @param options {Options} - The options used to setup the middleware. + */ + init(options: Options): void; + /** + * Method to fetch a client's hit count and reset time. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo | undefined} - The number of hits and reset time for that client. + * + * @public + */ + get(key: string): Promise; + /** + * Method to increment a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client. + * + * @public + */ + increment(key: string): Promise; + /** + * Method to decrement a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @public + */ + decrement(key: string): Promise; + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @public + */ + resetKey(key: string): Promise; + /** + * Method to reset everyone's hit counter. + * + * @public + */ + resetAll(): Promise; + /** + * Method to stop the timer (if currently running) and prevent any memory + * leaks. + * + * @public + */ + shutdown(): void; + /** + * Recycles a client by setting its hit count to zero, and reset time to + * `windowMs` milliseconds from now. + * + * NOT to be confused with `#resetKey()`, which removes a client from both the + * `current` and `previous` maps. + * + * @param client {Client} - The client to recycle. + * @param now {number} - The current time, to which the `windowMs` is added to get the `resetTime` for the client. + * + * @return {Client} - The modified client that was passed in, to allow for chaining. + */ + private resetClient; + /** + * Retrieves or creates a client, given a key. Also ensures that the client being + * returned is in the `current` map. + * + * @param key {string} - The key under which the client is (or is to be) stored. + * + * @returns {Client} - The requested client. + */ + private getClient; + /** + * Move current clients to previous, create a new map for current. + * + * This function is called every `windowMs`. + */ + private clearExpired; +} +/** + * + * Create an instance of IP rate-limiting middleware for Express. + * + * @param passedOptions {Options} - Options to configure the rate limiter. + * + * @returns {RateLimitRequestHandler} - The middleware that rate-limits clients based on your configuration. + * + * @public + */ +export declare const rateLimit: (passedOptions?: Partial) => RateLimitRequestHandler; + +export { + rateLimit as default, +}; + +export {}; diff --git a/tools/ui/node_modules/express-rate-limit/dist/index.d.ts b/tools/ui/node_modules/express-rate-limit/dist/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c93d9244e5e4c56e8e9e90accfe28e11599c8447 --- /dev/null +++ b/tools/ui/node_modules/express-rate-limit/dist/index.d.ts @@ -0,0 +1,672 @@ +// Generated by dts-bundle-generator v8.1.2 + +import { NextFunction, Request, RequestHandler, Response } from 'express'; + +/** + * Returns the IP address itself for IPv4, or a CIDR-notation subnet for IPv6. + * + * If you write a custom keyGenerator that allows a fallback to IP address for + * unauthenticated users, return ipKeyGenerator(req.ip) rather than just req.ip. + * + * For more information, {@see Options.ipv6Subnet}. + * + * @param ip {string} - The IP address to process, usually request.ip. + * @param ipv6Subnet {number | false} - The subnet mask for IPv6 addresses. + * + * @returns {string} - The key generated from the IP address + * + * @public + */ +export declare function ipKeyGenerator(ip: string, ipv6Subnet?: number | false): string; +declare const SUPPORTED_DRAFT_VERSIONS: readonly [ + "draft-6", + "draft-7", + "draft-8" +]; +declare const validations: { + enabled: { + [key: string]: boolean; + }; + disable(): void; + /** + * Checks whether the IP address is valid, and that it does not have a port + * number in it. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_invalid_ip_address. + * + * @param ip {string | undefined} - The IP address provided by Express as request.ip. + * + * @returns {void} + */ + ip(ip: string | undefined): void; + /** + * Makes sure the trust proxy setting is not set to `true`. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_permissive_trust_proxy. + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + trustProxy(request: Request): void; + /** + * Makes sure the trust proxy setting is set in case the `X-Forwarded-For` + * header is present. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_unset_trust_proxy. + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + xForwardedForHeader(request: Request): void; + /** + * Alert the user if the Forwarded header is set (standardized version of X-Forwarded-For - not supported by express as of version 5.1.0) + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + forwardedHeader(request: Request): void; + /** + * Ensures totalHits value from store is a positive integer. + * + * @param hits {any} - The `totalHits` returned by the store. + */ + positiveHits(hits: any): void; + /** + * Ensures a single store instance is not used with multiple express-rate-limit instances + */ + unsharedStore(store: Store): void; + /** + * Ensures a given key is incremented only once per request. + * + * @param request {Request} - The Express request object. + * @param store {Store} - The store class. + * @param key {string} - The key used to store the client's hit count. + * + * @returns {void} + */ + singleCount(request: Request, store: Store, key: string): void; + /** + * Warns the user that the behaviour for `max: 0` / `limit: 0` is + * changing in the next major release. + * + * @param limit {number} - The maximum number of hits per client. + * + * @returns {void} + */ + limit(limit: number): void; + /** + * Warns the user that the `draft_polli_ratelimit_headers` option is deprecated + * and will be removed in the next major release. + * + * @param draft_polli_ratelimit_headers {any | undefined} - The now-deprecated setting that was used to enable standard headers. + * + * @returns {void} + */ + draftPolliHeaders(draft_polli_ratelimit_headers?: any): void; + /** + * Warns the user that the `onLimitReached` option is deprecated and + * will be removed in the next major release. + * + * @param onLimitReached {any | undefined} - The maximum number of hits per client. + * + * @returns {void} + */ + onLimitReached(onLimitReached?: any): void; + /** + * Warns the user when an invalid/unsupported version of the draft spec is passed. + * + * @param version {any | undefined} - The version passed by the user. + * + * @returns {void} + */ + headersDraftVersion(version?: any): void; + /** + * Warns the user when the selected headers option requires a reset time but + * the store does not provide one. + * + * @param resetTime {Date | undefined} - The timestamp when the client's hit count will be reset. + * + * @returns {void} + */ + headersResetTime(resetTime?: Date): void; + knownOptions(passedOptions?: Partial): void; + /** + * Checks the options.validate setting to ensure that only recognized + * validations are enabled or disabled. + * + * If any unrecognized values are found, an error is logged that + * includes the list of supported validations. + */ + validationsConfig(): void; + /** + * Checks to see if the instance was created inside of a request handler, + * which would prevent it from working correctly, with the default memory + * store (or any other store with localKeys.) + */ + creationStack(store: Store): void; + ipv6Subnet(ipv6Subnet?: any): void; + ipv6SubnetOrKeyGenerator(options: Partial): void; + keyGeneratorIpFallback(keyGenerator?: ValueDeterminingMiddleware): void; + /** + * Checks to see if the window duration is greater than 2^32 - 1. This is only + * called by the default MemoryStore, since it uses Node's setInterval method. + * + * See https://nodejs.org/api/timers.html#setintervalcallback-delay-args. + */ + windowMs(windowMs: number): void; +}; +export type Validations = typeof validations; +/** + * Basic logging function + * + * @param error {unknown} - The error to log + * @param message {string | undefined} - Additional details about the error + */ +export type LoggerFn = (error: unknown, message?: string) => void; +/** + * Minimal interface for logging warnings and errors + */ +export type Logger = { + /** + * Function to log an error + */ + error: LoggerFn; + /** + * Function to log a warning + */ + warn: LoggerFn; +}; +/** + * Callback that fires when a client's hit counter is incremented. + * + * @param error {Error | undefined} - The error that occurred, if any. + * @param totalHits {number} - The number of hits for that client so far. + * @param resetTime {Date | undefined} - The time when the counter resets. + */ +export type IncrementCallback = (error: Error | undefined, totalHits: number, resetTime: Date | undefined) => void; +/** + * Method (in the form of middleware) to generate/retrieve a value based on the + * incoming request. + * + * @param request {Request} - The Express request object. + * @param response {Response} - The Express response object. + * + * @returns {T} - The value needed. + */ +export type ValueDeterminingMiddleware = (request: Request, response: Response) => T | Promise; +/** + * Express request handler that sends back a response when a client is + * rate-limited. + * + * @param request {Request} - The Express request object. + * @param response {Response} - The Express response object. + * @param next {NextFunction} - The Express `next` function, can be called to skip responding. + * @param optionsUsed {Options} - The options used to set up the middleware. + */ +export type RateLimitExceededEventHandler = (request: Request, response: Response, next: NextFunction, optionsUsed: Options) => void; +/** + * Event callback that is triggered on a client's first request that exceeds the limit + * but not for subsequent requests. May be used for logging, etc. Should *not* + * send a response. + * + * @param request {Request} - The Express request object. + * @param response {Response} - The Express response object. + * @param optionsUsed {Options} - The options used to set up the middleware. + */ +export type RateLimitReachedEventHandler = (request: Request, response: Response, optionsUsed: Options) => void; +/** + * Data returned from the `Store` when a client's hit counter is incremented. + * + * @property totalHits {number} - The number of hits for that client so far. + * @property resetTime {Date | undefined} - The time when the counter resets. + */ +export type ClientRateLimitInfo = { + totalHits: number; + resetTime: Date | undefined; +}; +export type IncrementResponse = ClientRateLimitInfo; +/** + * A modified Express request handler with the rate limit functions. + */ +export type RateLimitRequestHandler = RequestHandler & { + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + resetKey: (key: string) => void; + /** + * Method to fetch a client's hit count and reset time. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client. + */ + getKey: (key: string) => Promise | ClientRateLimitInfo | undefined; +}; +/** + * An interface that all hit counter stores must implement. + * + * @deprecated 6.x - Implement the `Store` interface instead. + */ +export type LegacyStore = { + /** + * Method to increment a client's hit counter. + * + * @param key {string} - The identifier for a client. + * @param callback {IncrementCallback} - The callback to call once the counter is incremented. + */ + incr: (key: string, callback: IncrementCallback) => void; + /** + * Method to decrement a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + decrement: (key: string) => void; + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + resetKey: (key: string) => void; + /** + * Method to reset everyone's hit counter. + */ + resetAll?: () => void; +}; +/** + * An interface that all hit counter stores must implement. + */ +export type Store = { + /** + * Method that initializes the store, and has access to the options passed to + * the middleware too. + * + * Called once during initialization. + * + * Errors / promise rejections will be caught and logged. + * + * Note that the result is not awaited - other store methods (such as increment) may be called before init returns and/or after it throws/rejects. + * + * @param options {Options} - The options used to setup the middleware. + */ + init?: (options: Options) => void | Promise; + /** + * Method to fetch a client's hit count and reset time. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client. + */ + get?: (key: string) => Promise | ClientRateLimitInfo | undefined; + /** + * Method to increment a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @returns {IncrementResponse | undefined} - The number of hits and reset time for that client. + */ + increment: (key: string) => Promise | IncrementResponse; + /** + * Method to decrement a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + decrement: (key: string) => Promise | void; + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + */ + resetKey: (key: string) => Promise | void; + /** + * Method to reset everyone's hit counter. + */ + resetAll?: () => Promise | void; + /** + * Method to shutdown the store, stop timers, and release all resources. + */ + shutdown?: () => Promise | void; + /** + * Flag to indicate that keys incremented in one instance of this store can + * not affect other instances. Typically false if a database is used, true for + * MemoryStore. + * + * Used to help detect double-counting misconfigurations. + */ + localKeys?: boolean; + /** + * Optional value that the store prepends to keys + * + * Used by the double-count check to avoid false-positives when a key is counted + * twice, but with different prefixes. + */ + prefix?: string; +}; +export type DraftHeadersVersion = (typeof SUPPORTED_DRAFT_VERSIONS)[number]; +/** + * Validate configuration object for enabling or disabling specific validations. + * + * The keys must also be keys in the validations object, except `enable`, `disable`, + * and `default`. + */ +export type EnabledValidations = { + [key in keyof Omit | "default"]?: boolean; +}; +/** + * The configuration options for the rate limiter. + */ +export type Options = { + /** + * How long we should remember the requests. + * + * Defaults to `60000` ms (= 1 minute). + */ + windowMs: number; + /** + * The maximum number of connections to allow during the `window` before + * rate limiting the client. + * + * Can be the limit itself as a number or express middleware that parses + * the request and then figures out the limit. + * + * Defaults to `5`. + */ + limit: number | ValueDeterminingMiddleware; + /** + * The response body to send back when a client is rate limited. + * + * Defaults to `'Too many requests, please try again later.'` + */ + message: any | ValueDeterminingMiddleware; + /** + * The HTTP status code to send back when a client is rate limited. + * + * Defaults to `HTTP 429 Too Many Requests` (RFC 6585). + */ + statusCode: number; + /** + * Whether to send `X-RateLimit-*` headers with the rate limit and the number + * of requests. + * + * Defaults to `true` (for backward compatibility). + */ + legacyHeaders: boolean; + /** + * Whether to enable support for the standardized rate limit headers (`RateLimit-*`). + * + * Defaults to `false` (for backward compatibility, but its use is recommended). + */ + standardHeaders: boolean | DraftHeadersVersion; + /** + * The name used to identify the quota policy in the `RateLimit` headers as per + * the 8th draft of the IETF specification. + * + * Defaults to `{limit}-in-{window}`. + */ + identifier: string | ValueDeterminingMiddleware; + /** + * The name of the property on the request object to store the rate limit info. + * + * Defaults to `rateLimit`. + */ + requestPropertyName: string; + /** + * If `true`, the library will (by default) skip all requests that have a 4XX + * or 5XX status. + * + * Defaults to `false`. + */ + skipFailedRequests: boolean; + /** + * If `true`, the library will (by default) skip all requests that have a + * status code less than 400. + * + * Defaults to `false`. + */ + skipSuccessfulRequests: boolean; + /** + * Method to generate custom identifiers for clients. + * + * By default, the client's IP address is used. + */ + keyGenerator: ValueDeterminingMiddleware; + /** + * IPv6 subnet mask applied to IPv6 addresses in the default keyGenerator. + * + * Default is 56. The valid range is technically 1-128 but the value should + * generally be in the 32-64 range. + * + * Smaller numbers are more aggressive, larger numbers are more lenient. Try + * bumping to 60 or 64 if you see evidence of users being blocked incorrectly. + * + * May also be set to a function that returns a number based on the request. + * + * See the documentation for more info: + * https://express-rate-limit.mintlify.app/reference/configuration#ipv6subnet. + */ + ipv6Subnet: 64 | 60 | 56 | 52 | 50 | 48 | 32 | number | ValueDeterminingMiddleware | false; + /** + * Express request handler that sends back a response when a client is + * rate-limited. + * + * By default, sends back the `statusCode` and `message` set via the options. + */ + handler: RateLimitExceededEventHandler; + /** + * Method (in the form of middleware) to determine whether or not this request + * counts towards a client's quota. + * + * By default, skips no requests. + */ + skip: ValueDeterminingMiddleware; + /** + * Method to determine whether or not the request counts as 'successful'. Used + * when either `skipSuccessfulRequests` or `skipFailedRequests` is set to true. + * + * By default, requests with a response status code less than 400 are considered + * successful. + */ + requestWasSuccessful: ValueDeterminingMiddleware; + /** + * The `Store` to use to store the hit count for each client. + * + * By default, the built-in `MemoryStore` will be used. + */ + store: Store | LegacyStore; + /** + * The list of validation checks that should run. + */ + validate: boolean | EnabledValidations; + /** + * Whether to send `X-RateLimit-*` headers with the rate limit and the number + * of requests. + * + * @deprecated 6.x - This option was renamed to `legacyHeaders`. + */ + headers?: boolean; + /** + * The maximum number of connections to allow during the `window` before + * rate limiting the client. + * + * Can be the limit itself as a number or express middleware that parses + * the request and then figures out the limit. + * + * @deprecated 7.x - This option was renamed to `limit`. However, it will not + * be removed from the library in the foreseeable future. + */ + max?: number | ValueDeterminingMiddleware; + /** + * If the Store generates an error, allow the request to pass. + */ + passOnStoreError: boolean; + /** + * The logger to use to log errors. If absent, logs to the console. + */ + logger: Logger; +}; +/** + * The extended request object that includes information about the client's + * rate limit. + */ +export type AugmentedRequest = Request & { + [key: string]: RateLimitInfo; +}; +/** + * The rate limit related information for each client included in the + * Express request object. + */ +export type RateLimitInfo = { + limit: number; + used: number; + remaining: number; + resetTime: Date | undefined; + key: string; +}; +/** + * The record that stores information about a client - namely, how many times + * they have hit the endpoint, and when their hit count resets. + * + * Similar to `ClientRateLimitInfo`, except `resetTime` is a compulsory field. + */ +export type Client = { + totalHits: number; + resetTime: Date; +}; +/** + * A `Store` that stores the hit count for each client in memory. + * + * @public + */ +export declare class MemoryStore implements Store { + private validations?; + /** + * The duration of time before which all hit counts are reset (in milliseconds). + */ + windowMs: number; + /** + * These two maps store usage (requests) and reset time by key (for example, IP + * addresses or API keys). + * + * They are split into two to avoid having to iterate through the entire set to + * determine which ones need reset. Instead, `Client`s are moved from `previous` + * to `current` as they hit the endpoint. Once `windowMs` has elapsed, all clients + * left in `previous`, i.e., those that have not made any recent requests, are + * known to be expired and can be deleted in bulk. + */ + previous: Map; + current: Map; + /** + * A reference to the active timer. + */ + interval?: NodeJS.Timeout; + /** + * Confirmation that the keys incremented in once instance of MemoryStore + * cannot affect other instances. + */ + localKeys: boolean; + constructor(validations?: Validations | undefined); + /** + * Method that initializes the store. + * + * @param options {Options} - The options used to setup the middleware. + */ + init(options: Options): void; + /** + * Method to fetch a client's hit count and reset time. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo | undefined} - The number of hits and reset time for that client. + * + * @public + */ + get(key: string): Promise; + /** + * Method to increment a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client. + * + * @public + */ + increment(key: string): Promise; + /** + * Method to decrement a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @public + */ + decrement(key: string): Promise; + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @public + */ + resetKey(key: string): Promise; + /** + * Method to reset everyone's hit counter. + * + * @public + */ + resetAll(): Promise; + /** + * Method to stop the timer (if currently running) and prevent any memory + * leaks. + * + * @public + */ + shutdown(): void; + /** + * Recycles a client by setting its hit count to zero, and reset time to + * `windowMs` milliseconds from now. + * + * NOT to be confused with `#resetKey()`, which removes a client from both the + * `current` and `previous` maps. + * + * @param client {Client} - The client to recycle. + * @param now {number} - The current time, to which the `windowMs` is added to get the `resetTime` for the client. + * + * @return {Client} - The modified client that was passed in, to allow for chaining. + */ + private resetClient; + /** + * Retrieves or creates a client, given a key. Also ensures that the client being + * returned is in the `current` map. + * + * @param key {string} - The key under which the client is (or is to be) stored. + * + * @returns {Client} - The requested client. + */ + private getClient; + /** + * Move current clients to previous, create a new map for current. + * + * This function is called every `windowMs`. + */ + private clearExpired; +} +/** + * + * Create an instance of IP rate-limiting middleware for Express. + * + * @param passedOptions {Options} - Options to configure the rate limiter. + * + * @returns {RateLimitRequestHandler} - The middleware that rate-limits clients based on your configuration. + * + * @public + */ +export declare const rateLimit: (passedOptions?: Partial) => RateLimitRequestHandler; + +export { + rateLimit as default, +}; + +export {}; diff --git a/tools/ui/node_modules/express-rate-limit/dist/index.mjs b/tools/ui/node_modules/express-rate-limit/dist/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..769d836facd26520139041816016fd114f16a770 --- /dev/null +++ b/tools/ui/node_modules/express-rate-limit/dist/index.mjs @@ -0,0 +1,986 @@ +// source/ip-key-generator.ts +import { isIPv6 } from "node:net"; +import { Address6 } from "ip-address"; +function ipKeyGenerator(ip, ipv6Subnet = 56) { + if (isIPv6(ip)) { + const address = new Address6(ip); + if (address.is4()) return address.to4().correctForm(); + if (ipv6Subnet) { + const subnet = new Address6(`${ip}/${ipv6Subnet}`); + return subnet.networkForm(); + } + } + return ip; +} + +// source/memory-store.ts +var MemoryStore = class { + constructor(validations2) { + this.validations = validations2; + /** + * These two maps store usage (requests) and reset time by key (for example, IP + * addresses or API keys). + * + * They are split into two to avoid having to iterate through the entire set to + * determine which ones need reset. Instead, `Client`s are moved from `previous` + * to `current` as they hit the endpoint. Once `windowMs` has elapsed, all clients + * left in `previous`, i.e., those that have not made any recent requests, are + * known to be expired and can be deleted in bulk. + */ + this.previous = /* @__PURE__ */ new Map(); + this.current = /* @__PURE__ */ new Map(); + /** + * Confirmation that the keys incremented in once instance of MemoryStore + * cannot affect other instances. + */ + this.localKeys = true; + } + /** + * Method that initializes the store. + * + * @param options {Options} - The options used to setup the middleware. + */ + init(options) { + this.windowMs = options.windowMs; + this.validations?.windowMs(this.windowMs); + if (this.interval) clearInterval(this.interval); + this.interval = setInterval(() => { + this.clearExpired(); + }, this.windowMs); + this.interval.unref?.(); + } + /** + * Method to fetch a client's hit count and reset time. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo | undefined} - The number of hits and reset time for that client. + * + * @public + */ + async get(key) { + return this.current.get(key) ?? this.previous.get(key); + } + /** + * Method to increment a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client. + * + * @public + */ + async increment(key) { + const client = this.getClient(key); + const now = Date.now(); + if (client.resetTime.getTime() <= now) { + this.resetClient(client, now); + } + client.totalHits++; + return client; + } + /** + * Method to decrement a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @public + */ + async decrement(key) { + const client = this.getClient(key); + if (client.totalHits > 0) client.totalHits--; + } + /** + * Method to reset a client's hit counter. + * + * @param key {string} - The identifier for a client. + * + * @public + */ + async resetKey(key) { + this.current.delete(key); + this.previous.delete(key); + } + /** + * Method to reset everyone's hit counter. + * + * @public + */ + async resetAll() { + this.current.clear(); + this.previous.clear(); + } + /** + * Method to stop the timer (if currently running) and prevent any memory + * leaks. + * + * @public + */ + shutdown() { + clearInterval(this.interval); + void this.resetAll(); + } + /** + * Recycles a client by setting its hit count to zero, and reset time to + * `windowMs` milliseconds from now. + * + * NOT to be confused with `#resetKey()`, which removes a client from both the + * `current` and `previous` maps. + * + * @param client {Client} - The client to recycle. + * @param now {number} - The current time, to which the `windowMs` is added to get the `resetTime` for the client. + * + * @return {Client} - The modified client that was passed in, to allow for chaining. + */ + resetClient(client, now = Date.now()) { + client.totalHits = 0; + client.resetTime.setTime(now + this.windowMs); + return client; + } + /** + * Retrieves or creates a client, given a key. Also ensures that the client being + * returned is in the `current` map. + * + * @param key {string} - The key under which the client is (or is to be) stored. + * + * @returns {Client} - The requested client. + */ + getClient(key) { + if (this.current.has(key)) return this.current.get(key); + let client; + if (this.previous.has(key)) { + client = this.previous.get(key); + this.previous.delete(key); + } else { + client = { totalHits: 0, resetTime: /* @__PURE__ */ new Date() }; + this.resetClient(client); + } + this.current.set(key, client); + return client; + } + /** + * Move current clients to previous, create a new map for current. + * + * This function is called every `windowMs`. + */ + clearExpired() { + this.previous = this.current; + this.current = /* @__PURE__ */ new Map(); + } +}; + +// source/rate-limit.ts +import { isIPv6 as isIPv62 } from "node:net"; + +// source/console-logger.ts +var ConsoleLogger = { + warn(...args) { + console.warn(...args.reverse()); + }, + error(...args) { + console.error(...args.reverse()); + } +}; + +// source/headers.ts +import { Buffer } from "node:buffer"; +import { createHash } from "node:crypto"; +var SUPPORTED_DRAFT_VERSIONS = [ + "draft-6", + "draft-7", + "draft-8" +]; +var getResetSeconds = (windowMs, resetTime) => { + let resetSeconds; + if (resetTime) { + const deltaSeconds = Math.ceil((resetTime.getTime() - Date.now()) / 1e3); + resetSeconds = Math.max(0, deltaSeconds); + } else { + resetSeconds = Math.ceil(windowMs / 1e3); + } + return resetSeconds; +}; +var getPartitionKey = (key) => { + const hash = createHash("sha256"); + hash.update(key); + const partitionKey = hash.digest("hex").slice(0, 12); + return Buffer.from(partitionKey).toString("base64"); +}; +var setLegacyHeaders = (response, info) => { + if (response.headersSent) return; + response.setHeader("X-RateLimit-Limit", info.limit.toString()); + response.setHeader("X-RateLimit-Remaining", info.remaining.toString()); + if (info.resetTime instanceof Date) { + response.setHeader("Date", (/* @__PURE__ */ new Date()).toUTCString()); + response.setHeader( + "X-RateLimit-Reset", + Math.ceil(info.resetTime.getTime() / 1e3).toString() + ); + } +}; +var setDraft6Headers = (response, info, windowMs) => { + if (response.headersSent) return; + const windowSeconds = Math.ceil(windowMs / 1e3); + const resetSeconds = getResetSeconds(windowMs, info.resetTime); + response.setHeader("RateLimit-Policy", `${info.limit};w=${windowSeconds}`); + response.setHeader("RateLimit-Limit", info.limit.toString()); + response.setHeader("RateLimit-Remaining", info.remaining.toString()); + if (typeof resetSeconds === "number") + response.setHeader("RateLimit-Reset", resetSeconds.toString()); +}; +var setDraft7Headers = (response, info, windowMs) => { + if (response.headersSent) return; + const windowSeconds = Math.ceil(windowMs / 1e3); + const resetSeconds = getResetSeconds(windowMs, info.resetTime); + response.setHeader("RateLimit-Policy", `${info.limit};w=${windowSeconds}`); + response.setHeader( + "RateLimit", + `limit=${info.limit}, remaining=${info.remaining}, reset=${resetSeconds}` + ); +}; +var setDraft8Headers = (response, info, windowMs, name, key) => { + if (response.headersSent) return; + const windowSeconds = Math.ceil(windowMs / 1e3); + const resetSeconds = getResetSeconds(windowMs, info.resetTime); + const partitionKey = getPartitionKey(key); + const header = `r=${info.remaining}; t=${resetSeconds}`; + const policy = `q=${info.limit}; w=${windowSeconds}; pk=:${partitionKey}:`; + response.append("RateLimit", `"${name}"; ${header}`); + response.append("RateLimit-Policy", `"${name}"; ${policy}`); +}; +var setRetryAfterHeader = (response, info, windowMs) => { + if (response.headersSent) return; + const resetSeconds = getResetSeconds(windowMs, info.resetTime); + response.setHeader("Retry-After", resetSeconds.toString()); +}; + +// source/utils.ts +var omitUndefinedProperties = (passedOptions) => { + const omittedOptions = {}; + for (const k of Object.keys(passedOptions)) { + const key = k; + if (passedOptions[key] !== void 0) { + omittedOptions[key] = passedOptions[key]; + } + } + return omittedOptions; +}; + +// source/validations.ts +import { isIP } from "node:net"; +var ValidationError = class extends Error { + /** + * The code must be a string, in snake case and all capital, that starts with + * the substring `ERR_ERL_`. + * + * The message must be a string, starting with an uppercase character, + * describing the issue in detail. + */ + constructor(code, message) { + const url = `https://express-rate-limit.github.io/${code}/`; + super(`${message} See ${url} for more information.`); + this.name = this.constructor.name; + this.code = code; + this.help = url; + } +}; +var ChangeWarning = class extends ValidationError { +}; +var usedStores = /* @__PURE__ */ new Set(); +var singleCountKeys = /* @__PURE__ */ new WeakMap(); +var validations = { + enabled: { + default: true + }, + // Should be EnabledValidations type, but that's a circular reference + disable() { + for (const k of Object.keys(this.enabled)) this.enabled[k] = false; + }, + /** + * Checks whether the IP address is valid, and that it does not have a port + * number in it. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_invalid_ip_address. + * + * @param ip {string | undefined} - The IP address provided by Express as request.ip. + * + * @returns {void} + */ + ip(ip) { + if (ip === void 0) { + throw new ValidationError( + "ERR_ERL_UNDEFINED_IP_ADDRESS", + `An undefined 'request.ip' was detected. This might indicate a misconfiguration or the connection being destroyed prematurely.` + ); + } + if (!isIP(ip)) { + throw new ValidationError( + "ERR_ERL_INVALID_IP_ADDRESS", + `An invalid 'request.ip' (${ip}) was detected. Consider passing a custom 'keyGenerator' function to the rate limiter.` + ); + } + }, + /** + * Makes sure the trust proxy setting is not set to `true`. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_permissive_trust_proxy. + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + trustProxy(request) { + if (request.app.get("trust proxy") === true) { + throw new ValidationError( + "ERR_ERL_PERMISSIVE_TRUST_PROXY", + `The Express 'trust proxy' setting is true, which allows anyone to trivially bypass IP-based rate limiting.` + ); + } + }, + /** + * Makes sure the trust proxy setting is set in case the `X-Forwarded-For` + * header is present. + * + * See https://github.com/express-rate-limit/express-rate-limit/wiki/Error-Codes#err_erl_unset_trust_proxy. + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + xForwardedForHeader(request) { + if (request.headers["x-forwarded-for"] && request.app.get("trust proxy") === false) { + throw new ValidationError( + "ERR_ERL_UNEXPECTED_X_FORWARDED_FOR", + `The 'X-Forwarded-For' header is set but the Express 'trust proxy' setting is false (default). This could indicate a misconfiguration which would prevent express-rate-limit from accurately identifying users.` + ); + } + }, + /** + * Alert the user if the Forwarded header is set (standardized version of X-Forwarded-For - not supported by express as of version 5.1.0) + * + * @param request {Request} - The Express request object. + * + * @returns {void} + */ + forwardedHeader(request) { + if (request.headers.forwarded && request.ip === request.socket?.remoteAddress) { + throw new ValidationError( + "ERR_ERL_FORWARDED_HEADER", + `The 'Forwarded' header (standardized X-Forwarded-For) is set but currently being ignored. Add a custom keyGenerator to use a value from this header.` + ); + } + }, + /** + * Ensures totalHits value from store is a positive integer. + * + * @param hits {any} - The `totalHits` returned by the store. + */ + positiveHits(hits) { + if (typeof hits !== "number" || hits < 1 || hits !== Math.round(hits)) { + throw new ValidationError( + "ERR_ERL_INVALID_HITS", + `The totalHits value returned from the store must be a positive integer, got ${hits}` + ); + } + }, + /** + * Ensures a single store instance is not used with multiple express-rate-limit instances + */ + unsharedStore(store) { + if (usedStores.has(store)) { + const maybeUniquePrefix = store?.localKeys ? "" : " (with a unique prefix)"; + throw new ValidationError( + "ERR_ERL_STORE_REUSE", + `A Store instance must not be shared across multiple rate limiters. Create a new instance of ${store.constructor.name}${maybeUniquePrefix} for each limiter instead.` + ); + } + usedStores.add(store); + }, + /** + * Ensures a given key is incremented only once per request. + * + * @param request {Request} - The Express request object. + * @param store {Store} - The store class. + * @param key {string} - The key used to store the client's hit count. + * + * @returns {void} + */ + singleCount(request, store, key) { + let storeKeys = singleCountKeys.get(request); + if (!storeKeys) { + storeKeys = /* @__PURE__ */ new Map(); + singleCountKeys.set(request, storeKeys); + } + const storeKey = store.localKeys ? store : store.constructor.name; + let keys = storeKeys.get(storeKey); + if (!keys) { + keys = []; + storeKeys.set(storeKey, keys); + } + const prefixedKey = `${store.prefix ?? ""}${key}`; + if (keys.includes(prefixedKey)) { + throw new ValidationError( + "ERR_ERL_DOUBLE_COUNT", + `The hit count for ${key} was incremented more than once for a single request.` + ); + } + keys.push(prefixedKey); + }, + /** + * Warns the user that the behaviour for `max: 0` / `limit: 0` is + * changing in the next major release. + * + * @param limit {number} - The maximum number of hits per client. + * + * @returns {void} + */ + limit(limit) { + if (limit === 0) { + throw new ChangeWarning( + "WRN_ERL_MAX_ZERO", + "Setting limit or max to 0 disables rate limiting in express-rate-limit v6 and older, but will cause all requests to be blocked in v7" + ); + } + }, + /** + * Warns the user that the `draft_polli_ratelimit_headers` option is deprecated + * and will be removed in the next major release. + * + * @param draft_polli_ratelimit_headers {any | undefined} - The now-deprecated setting that was used to enable standard headers. + * + * @returns {void} + */ + draftPolliHeaders(draft_polli_ratelimit_headers) { + if (draft_polli_ratelimit_headers) { + throw new ChangeWarning( + "WRN_ERL_DEPRECATED_DRAFT_POLLI_HEADERS", + `The draft_polli_ratelimit_headers configuration option is deprecated and has been removed in express-rate-limit v7, please set standardHeaders: 'draft-6' instead.` + ); + } + }, + /** + * Warns the user that the `onLimitReached` option is deprecated and + * will be removed in the next major release. + * + * @param onLimitReached {any | undefined} - The maximum number of hits per client. + * + * @returns {void} + */ + onLimitReached(onLimitReached) { + if (onLimitReached) { + throw new ChangeWarning( + "WRN_ERL_DEPRECATED_ON_LIMIT_REACHED", + "The onLimitReached configuration option is deprecated and has been removed in express-rate-limit v7." + ); + } + }, + /** + * Warns the user when an invalid/unsupported version of the draft spec is passed. + * + * @param version {any | undefined} - The version passed by the user. + * + * @returns {void} + */ + headersDraftVersion(version) { + if (typeof version !== "string" || // @ts-expect-error This is fine. If version is not in the array, it will just return false. + !SUPPORTED_DRAFT_VERSIONS.includes(version)) { + const versionString = SUPPORTED_DRAFT_VERSIONS.join(", "); + throw new ValidationError( + "ERR_ERL_HEADERS_UNSUPPORTED_DRAFT_VERSION", + `standardHeaders: only the following versions of the IETF draft specification are supported: ${versionString}.` + ); + } + }, + /** + * Warns the user when the selected headers option requires a reset time but + * the store does not provide one. + * + * @param resetTime {Date | undefined} - The timestamp when the client's hit count will be reset. + * + * @returns {void} + */ + headersResetTime(resetTime) { + if (!resetTime) { + throw new ValidationError( + "ERR_ERL_HEADERS_NO_RESET", + `standardHeaders: 'draft-7' requires a 'resetTime', but the store did not provide one. The 'windowMs' value will be used instead, which may cause clients to wait longer than necessary.` + ); + } + }, + knownOptions(passedOptions) { + if (!passedOptions) return; + const optionsMap = { + windowMs: true, + limit: true, + message: true, + statusCode: true, + legacyHeaders: true, + standardHeaders: true, + identifier: true, + requestPropertyName: true, + skipFailedRequests: true, + skipSuccessfulRequests: true, + keyGenerator: true, + ipv6Subnet: true, + handler: true, + skip: true, + requestWasSuccessful: true, + store: true, + validate: true, + headers: true, + max: true, + passOnStoreError: true, + logger: true + }; + const validOptions = Object.keys(optionsMap).concat( + "draft_polli_ratelimit_headers", + // not a valid option anymore, but we have a more specific check for this one, so don't warn for it here + // from express-slow-down - https://github.com/express-rate-limit/express-slow-down/blob/main/source/types.ts#L65 + "delayAfter", + "delayMs", + "maxDelayMs" + ); + for (const key of Object.keys(passedOptions)) { + if (!validOptions.includes(key)) { + throw new ValidationError( + "ERR_ERL_UNKNOWN_OPTION", + `Unexpected configuration option: ${key}` + // todo: suggest a valid option with a short levenstein distance? + ); + } + } + }, + /** + * Checks the options.validate setting to ensure that only recognized + * validations are enabled or disabled. + * + * If any unrecognized values are found, an error is logged that + * includes the list of supported validations. + */ + validationsConfig() { + const supportedValidations = Object.keys(this).filter( + (k) => !["enabled", "disable"].includes(k) + ); + supportedValidations.push("default"); + for (const key of Object.keys(this.enabled)) { + if (!supportedValidations.includes(key)) { + throw new ValidationError( + "ERR_ERL_UNKNOWN_VALIDATION", + `options.validate.${key} is not recognized. Supported validate options are: ${supportedValidations.join( + ", " + )}.` + ); + } + } + }, + /** + * Checks to see if the instance was created inside of a request handler, + * which would prevent it from working correctly, with the default memory + * store (or any other store with localKeys.) + */ + creationStack(store) { + const { stack } = new Error( + "express-rate-limit validation check (set options.validate.creationStack=false to disable)" + ); + if (stack?.includes("Layer.handle [as handle_request]") || // express v4 + stack?.includes("Layer.handleRequest")) { + if (!store.localKeys) { + throw new ValidationError( + "ERR_ERL_CREATED_IN_REQUEST_HANDLER", + "express-rate-limit instance should *usually* be created at app initialization, not when responding to a request." + ); + } + throw new ValidationError( + "ERR_ERL_CREATED_IN_REQUEST_HANDLER", + "express-rate-limit instance should be created at app initialization, not when responding to a request." + ); + } + }, + ipv6Subnet(ipv6Subnet) { + if (ipv6Subnet === false) { + return; + } + if (!Number.isInteger(ipv6Subnet) || ipv6Subnet < 32 || ipv6Subnet > 64) { + throw new ValidationError( + "ERR_ERL_IPV6_SUBNET", + `Unexpected ipv6Subnet value: ${ipv6Subnet}. Expected an integer between 32 and 64 (usually 48-64).` + ); + } + }, + ipv6SubnetOrKeyGenerator(options) { + if (options.ipv6Subnet !== void 0 && options.keyGenerator) { + throw new ValidationError( + "ERR_ERL_IPV6SUBNET_OR_KEYGENERATOR", + `Incompatible options: the 'ipv6Subnet' option is ignored when a custom 'keyGenerator' function is also set.` + ); + } + }, + keyGeneratorIpFallback(keyGenerator) { + if (!keyGenerator) { + return; + } + const src = keyGenerator.toString(); + if ((src.includes("req.ip") || src.includes("request.ip")) && !src.includes("ipKeyGenerator")) { + throw new ValidationError( + "ERR_ERL_KEY_GEN_IPV6", + "Custom keyGenerator appears to use request IP without calling the ipKeyGenerator helper function for IPv6 addresses. This could allow IPv6 users to bypass limits." + ); + } + }, + /** + * Checks to see if the window duration is greater than 2^32 - 1. This is only + * called by the default MemoryStore, since it uses Node's setInterval method. + * + * See https://nodejs.org/api/timers.html#setintervalcallback-delay-args. + */ + windowMs(windowMs) { + const SET_TIMEOUT_MAX = 2 ** 31 - 1; + if (typeof windowMs !== "number" || Number.isNaN(windowMs) || windowMs < 1 || windowMs > SET_TIMEOUT_MAX) { + throw new ValidationError( + "ERR_ERL_WINDOW_MS", + `Invalid windowMs value: ${windowMs}${typeof windowMs !== "number" ? ` (${typeof windowMs})` : ""}, must be a number between 1 and ${SET_TIMEOUT_MAX} when using the default MemoryStore` + ); + } + } +}; +function validateLogger(logger) { + if (typeof logger !== "object" || typeof logger.error !== "function" || typeof logger.warn !== "function") { + throw new TypeError( + "Provided logger does not implement the Logger interface" + ); + } +} +var getValidations = (_enabled, logger) => { + validateLogger(logger); + let enabled; + if (typeof _enabled === "boolean") { + enabled = { + default: _enabled + }; + } else { + enabled = { + default: true, + ..._enabled + }; + } + const wrappedValidations = { enabled }; + for (const [name, validation] of Object.entries(validations)) { + if (typeof validation === "function") + wrappedValidations[name] = (...args) => { + if (!(enabled[name] ?? enabled.default)) { + return; + } + try { + ; + validation.apply( + wrappedValidations, + args + ); + } catch (error) { + if (error instanceof ChangeWarning) logger.warn(error); + else logger.error(error); + } + }; + } + return wrappedValidations; +}; + +// source/rate-limit.ts +var isLegacyStore = (store) => ( + // Check that `incr` exists but `increment` does not - store authors might want + // to keep both around for backwards compatibility. + typeof store.incr === "function" && typeof store.increment !== "function" +); +var promisifyStore = (passedStore) => { + if (!isLegacyStore(passedStore)) { + return passedStore; + } + const legacyStore = passedStore; + class PromisifiedStore { + async increment(key) { + return new Promise((resolve, reject) => { + legacyStore.incr( + key, + (error, totalHits, resetTime) => { + if (error) reject(error); + resolve({ totalHits, resetTime }); + } + ); + }); + } + async decrement(key) { + return legacyStore.decrement(key); + } + async resetKey(key) { + return legacyStore.resetKey(key); + } + /* istanbul ignore next */ + async resetAll() { + if (typeof legacyStore.resetAll === "function") + return legacyStore.resetAll(); + } + } + return new PromisifiedStore(); +}; +var getOptionsFromConfig = (config) => { + const { validations: validations2, ...directlyPassableEntries } = config; + return { + ...directlyPassableEntries, + validate: validations2.enabled + }; +}; +var parseOptions = (passedOptions) => { + const notUndefinedOptions = omitUndefinedProperties(passedOptions); + const logger = passedOptions.logger ?? ConsoleLogger; + const validations2 = getValidations( + notUndefinedOptions?.validate ?? true, + logger + ); + validations2.validationsConfig(); + validations2.knownOptions(passedOptions); + validations2.draftPolliHeaders( + // @ts-expect-error see the note above. + notUndefinedOptions.draft_polli_ratelimit_headers + ); + validations2.onLimitReached(notUndefinedOptions.onLimitReached); + if (notUndefinedOptions.ipv6Subnet !== void 0 && typeof notUndefinedOptions.ipv6Subnet !== "function") { + validations2.ipv6Subnet(notUndefinedOptions.ipv6Subnet); + } + validations2.keyGeneratorIpFallback(notUndefinedOptions.keyGenerator); + validations2.ipv6SubnetOrKeyGenerator(notUndefinedOptions); + let standardHeaders = notUndefinedOptions.standardHeaders ?? false; + if (standardHeaders === true) standardHeaders = "draft-6"; + const config = { + windowMs: 60 * 1e3, + limit: passedOptions.max ?? 5, + // `max` is deprecated, but support it anyways. + message: "Too many requests, please try again later.", + statusCode: 429, + legacyHeaders: passedOptions.headers ?? true, + identifier(request, _response) { + let duration = ""; + const property = config.requestPropertyName; + const { limit } = request[property]; + const seconds = config.windowMs / 1e3; + const minutes = config.windowMs / (1e3 * 60); + const hours = config.windowMs / (1e3 * 60 * 60); + const days = config.windowMs / (1e3 * 60 * 60 * 24); + if (seconds < 60) duration = `${seconds}sec`; + else if (minutes < 60) duration = `${minutes}min`; + else if (hours < 24) duration = `${hours}hr${hours > 1 ? "s" : ""}`; + else duration = `${days}day${days > 1 ? "s" : ""}`; + return `${limit}-in-${duration}`; + }, + requestPropertyName: "rateLimit", + skipFailedRequests: false, + skipSuccessfulRequests: false, + requestWasSuccessful: (_request, response) => response.statusCode < 400, + skip: (_request, _response) => false, + async keyGenerator(request, response) { + validations2.ip(request.ip); + validations2.trustProxy(request); + validations2.xForwardedForHeader(request); + validations2.forwardedHeader(request); + const ip = request.ip; + let subnet = 56; + if (isIPv62(ip)) { + subnet = typeof config.ipv6Subnet === "function" ? await config.ipv6Subnet(request, response) : config.ipv6Subnet; + if (typeof config.ipv6Subnet === "function") + validations2.ipv6Subnet(subnet); + } + return ipKeyGenerator(ip, subnet); + }, + ipv6Subnet: 56, + async handler(request, response, _next, _optionsUsed) { + response.status(config.statusCode); + const message = typeof config.message === "function" ? await config.message( + request, + response + ) : config.message; + if (!response.writableEnded) response.send(message); + }, + passOnStoreError: false, + // Allow the default options to be overridden by the passed options. + ...notUndefinedOptions, + // `standardHeaders` is resolved into a draft version above, use that. + standardHeaders, + // Note that this field is declared after the user's options are spread in, + // so that this field doesn't get overridden with an un-promisified store! + store: promisifyStore( + notUndefinedOptions.store ?? new MemoryStore(validations2) + ), + // Print an error to the console if a few known misconfigurations are detected. + validations: validations2, + logger + }; + if (typeof config.store.increment !== "function" || typeof config.store.decrement !== "function" || typeof config.store.resetKey !== "function" || config.store.resetAll !== void 0 && typeof config.store.resetAll !== "function" || config.store.init !== void 0 && typeof config.store.init !== "function") { + throw new TypeError( + "An invalid store was passed. Please ensure that the store is a class that implements the `Store` interface." + ); + } + return config; +}; +var handleAsyncErrors = (fn) => async (request, response, next) => { + try { + await Promise.resolve(fn(request, response, next)).catch(next); + } catch (error) { + next(error); + } +}; +var rateLimit = (passedOptions) => { + const config = parseOptions(passedOptions ?? {}); + const options = getOptionsFromConfig(config); + config.validations.creationStack(config.store); + config.validations.unsharedStore(config.store); + if (typeof config.store.init === "function") { + try { + const storeInit = config.store.init(options); + if (storeInit instanceof Promise) { + storeInit.catch( + (error) => config.logger.error( + error, + "express-rate-limit: async error during store initialization." + ) + ); + } + } catch (error) { + config.logger.error( + error, + "express-rate-limit: error during store initialization." + ); + } + } + const middleware = handleAsyncErrors( + async (request, response, next) => { + const closePromise = config.skipFailedRequests && new Promise((resolve) => response.once("close", resolve)); + const finishPromise = (config.skipFailedRequests || config.skipSuccessfulRequests) && new Promise((resolve) => response.once("finish", resolve)); + const errorPromise = config.skipFailedRequests && new Promise((resolve) => response.once("error", resolve)); + const skip = await config.skip(request, response); + if (skip) { + next(); + return; + } + const augmentedRequest = request; + const key = await config.keyGenerator(request, response); + let totalHits = 0; + let resetTime; + try { + const incrementResult = await config.store.increment(key); + totalHits = incrementResult.totalHits; + resetTime = incrementResult.resetTime; + } catch (error) { + if (config.passOnStoreError) { + config.logger.error( + error, + "express-rate-limit: error from store, allowing request without rate-limiting." + ); + next(); + return; + } + throw error; + } + config.validations.positiveHits(totalHits); + config.validations.singleCount(request, config.store, key); + const retrieveLimit = typeof config.limit === "function" ? config.limit(request, response) : config.limit; + const limit = await retrieveLimit; + config.validations.limit(limit); + const info = { + limit, + used: totalHits, + remaining: Math.max(limit - totalHits, 0), + resetTime, + key + }; + Object.defineProperty(info, "current", { + configurable: false, + enumerable: false, + value: totalHits + }); + augmentedRequest[config.requestPropertyName] = info; + if (config.legacyHeaders && !response.headersSent) { + setLegacyHeaders(response, info); + } + if (config.standardHeaders && !response.headersSent) { + switch (config.standardHeaders) { + case "draft-6": { + setDraft6Headers(response, info, config.windowMs); + break; + } + case "draft-7": { + config.validations.headersResetTime(info.resetTime); + setDraft7Headers(response, info, config.windowMs); + break; + } + case "draft-8": { + const retrieveName = typeof config.identifier === "function" ? config.identifier(request, response) : config.identifier; + const name = await retrieveName; + config.validations.headersResetTime(info.resetTime); + setDraft8Headers(response, info, config.windowMs, name, key); + break; + } + default: { + config.validations.headersDraftVersion(config.standardHeaders); + break; + } + } + } + if (config.skipFailedRequests || config.skipSuccessfulRequests) { + let decremented = false; + const decrementKey = async () => { + if (!decremented) { + await config.store.decrement(key); + decremented = true; + } + }; + if (config.skipFailedRequests) { + if (finishPromise) { + void finishPromise.then(async () => { + if (!await config.requestWasSuccessful(request, response)) + await decrementKey(); + }); + } + if (closePromise) { + void closePromise.then(async () => { + if (!response.writableEnded) await decrementKey(); + }); + } + if (errorPromise) { + void errorPromise.then(async () => { + await decrementKey(); + }); + } + } + if (config.skipSuccessfulRequests) { + if (finishPromise) { + void finishPromise.then(async () => { + if (await config.requestWasSuccessful(request, response)) + await decrementKey(); + }); + } + } + } + config.validations.disable(); + if (totalHits > limit) { + if (config.legacyHeaders || config.standardHeaders) { + setRetryAfterHeader(response, info, config.windowMs); + } + config.handler(request, response, next, options); + return; + } + next(); + } + ); + const getThrowFn = () => { + throw new Error("The current store does not support the get/getKey method"); + }; + middleware.resetKey = config.store.resetKey.bind(config.store); + middleware.getKey = typeof config.store.get === "function" ? config.store.get.bind(config.store) : getThrowFn; + return middleware; +}; +var rate_limit_default = rateLimit; +export { + MemoryStore, + rate_limit_default as default, + ipKeyGenerator, + rate_limit_default as rateLimit +}; diff --git a/tools/ui/node_modules/express-rate-limit/license.md b/tools/ui/node_modules/express-rate-limit/license.md new file mode 100644 index 0000000000000000000000000000000000000000..468dc35787669c62d4bf44df691cbdd15d967059 --- /dev/null +++ b/tools/ui/node_modules/express-rate-limit/license.md @@ -0,0 +1,20 @@ +# MIT License + +Copyright 2023 Nathan Friedly, Vedant K + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/express-rate-limit/package.json b/tools/ui/node_modules/express-rate-limit/package.json new file mode 100644 index 0000000000000000000000000000000000000000..efbf1dc9144caeb045bfb1ea6834ebeee659e519 --- /dev/null +++ b/tools/ui/node_modules/express-rate-limit/package.json @@ -0,0 +1,113 @@ +{ + "name": "express-rate-limit", + "version": "8.5.2", + "description": "Basic IP rate-limiting middleware for Express. Use to limit repeated requests to public APIs and/or endpoints such as password reset.", + "author": { + "name": "Nathan Friedly", + "url": "http://nfriedly.com/" + }, + "license": "MIT", + "homepage": "https://github.com/express-rate-limit/express-rate-limit", + "repository": { + "type": "git", + "url": "git+https://github.com/express-rate-limit/express-rate-limit.git" + }, + "funding": "https://github.com/sponsors/express-rate-limit", + "keywords": [ + "express-rate-limit", + "express", + "rate", + "limit", + "ratelimit", + "rate-limit", + "middleware", + "ip", + "auth", + "authorization", + "security", + "brute", + "force", + "bruteforce", + "brute-force", + "attack" + ], + "type": "module", + "exports": { + ".": { + "import": { + "types": "./dist/index.d.mts", + "default": "./dist/index.mjs" + }, + "require": { + "types": "./dist/index.d.cts", + "default": "./dist/index.cjs" + } + } + }, + "main": "./dist/index.cjs", + "module": "./dist/index.mjs", + "types": "./dist/index.d.ts", + "files": [ + "dist/", + "tsconfig.json" + ], + "engines": { + "node": ">= 16" + }, + "scripts": { + "clean": "del-cli dist/ coverage/ *.log *.tmp *.bak *.tgz", + "build:cjs": "esbuild --packages=external --platform=node --bundle --target=es2022 --format=cjs --outfile=dist/index.cjs --footer:js=\"module.exports = Object.assign(rateLimit, module.exports);\" source/index.ts", + "build:esm": "esbuild --packages=external --platform=node --bundle --target=es2022 --format=esm --outfile=dist/index.mjs source/index.ts", + "build:types": "dts-bundle-generator --out-file=dist/index.d.ts source/index.ts && cp dist/index.d.ts dist/index.d.cts && cp dist/index.d.ts dist/index.d.mts", + "compile": "run-s clean build:*", + "docs": "cd docs && mintlify dev", + "lint:code": "biome check", + "lint:docs": "prettier --check docs/ *.md", + "lint": "run-s lint:*", + "format:code": "biome check --write", + "format:docs": "prettier --write docs/ *.md", + "format": "run-s format:*", + "test:lib": "jest", + "test:ext": "cd test/external/ && bash run-all-tests", + "test": "run-s lint test:lib", + "format-test": "run-s format test:lib", + "pre-commit": "lint-staged", + "prepare": "run-s compile && husky" + }, + "dependencies": { + "ip-address": "^10.2.0" + }, + "peerDependencies": { + "express": ">= 4.11" + }, + "devDependencies": { + "@biomejs/biome": "2.4.6", + "@express-rate-limit/prettier": "1.1.1", + "@express-rate-limit/tsconfig": "1.0.2", + "@jest/globals": "30.4.1", + "@types/express": "5.0.6", + "@types/jest": "30.0.0", + "@types/node": "25.7.0", + "@types/supertest": "7.2.0", + "del-cli": "7.0.0", + "dts-bundle-generator": "8.1.2", + "esbuild": "0.28.0", + "express": "5.2.1", + "husky": "9.1.7", + "jest": "30.4.2", + "lint-staged": "17.0.4", + "mintlify": "4.2.559", + "npm-run-all": "4.1.5", + "prettier": "3.8.3", + "ratelimit-header-parser": "0.1.0", + "supertest": "7.2.2", + "ts-jest": "29.4.9", + "ts-node": "10.9.2", + "typescript": "5.9.3" + }, + "prettier": "@express-rate-limit/prettier", + "lint-staged": { + "*.{js,ts,json}": "biome check --write", + "*.{md,yaml}": "prettier --write" + } +} diff --git a/tools/ui/node_modules/express-rate-limit/readme.md b/tools/ui/node_modules/express-rate-limit/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..50705f6f2731292b37d117b2b99e20f4d98ab92b --- /dev/null +++ b/tools/ui/node_modules/express-rate-limit/readme.md @@ -0,0 +1,139 @@ +

express-rate-limit

+ +
+ +[![tests](https://img.shields.io/github/actions/workflow/status/express-rate-limit/express-rate-limit/ci.yaml)](https://github.com/express-rate-limit/express-rate-limit/actions/workflows/ci.yaml) +[![npm version](https://img.shields.io/npm/v/express-rate-limit.svg)](https://npmjs.org/package/express-rate-limit 'View this project on NPM') +[![npm downloads](https://img.shields.io/npm/dm/express-rate-limit)](https://www.npmjs.com/package/express-rate-limit) +[![license](https://img.shields.io/npm/l/express-rate-limit)](license.md) + +
+ +Basic rate-limiting middleware for [Express](http://expressjs.com/). Use to +limit repeated requests to public APIs and/or endpoints such as password reset. +Plays nice with +[express-slow-down](https://www.npmjs.com/package/express-slow-down) and +[ratelimit-header-parser](https://www.npmjs.com/package/ratelimit-header-parser). + +## Usage + +The [full documentation](https://express-rate-limit.mintlify.app/overview) is +available on-line. + +```ts +import { rateLimit } from 'express-rate-limit' + +const limiter = rateLimit({ + windowMs: 15 * 60 * 1000, // 15 minutes + limit: 100, // Limit each IP to 100 requests per `window` (here, per 15 minutes). + standardHeaders: 'draft-8', // draft-6: `RateLimit-*` headers; draft-7 & draft-8: combined `RateLimit` header + legacyHeaders: false, // Disable the `X-RateLimit-*` headers. + ipv6Subnet: 56, // Set to 60 or 64 to be less aggressive, or 52 or 48 to be more aggressive + // store: ... , // Redis, Memcached, etc. See below. +}) + +// Apply the rate limiting middleware to all requests. +app.use(limiter) +``` + +### Data Stores + +The rate limiter comes with a built-in memory store, and supports a variety of +[external data stores](https://express-rate-limit.mintlify.app/reference/stores). + +### Configuration + +All function options may be async. Click the name for additional info and +default values. + +| Option | Type | Remarks | +| -------------------------- | ----------------------------------------- | ----------------------------------------------------------------------------------------------- | +| [`windowMs`] | `number` | How long to remember requests for, in milliseconds. | +| [`limit`] | `number` \| `function` | How many requests to allow. | +| [`message`] | `string` \| `json` \| `function` | Response to return after limit is reached. | +| [`statusCode`] | `number` | HTTP status code after limit is reached (default is 429). | +| [`handler`] | `function` | Function to run after limit is reached (overrides `message` and `statusCode` settings, if set). | +| [`legacyHeaders`] | `boolean` | Enable the `X-Rate-Limit` header. | +| [`standardHeaders`] | `'draft-6'` \| `'draft-7'` \| `'draft-8'` | Enable the `Ratelimit` header. | +| [`identifier`] | `string` \| `function` | Name associated with the quota policy enforced by this rate limiter. | +| [`store`] | `Store` | Use a custom store to share hit counts across multiple nodes. | +| [`passOnStoreError`] | `boolean` | Allow (`true`) or block (`false`, default) traffic if the store becomes unavailable. | +| [`keyGenerator`] | `function` | Identify users (defaults to IP address). | +| [`ipv6Subnet`] | `number` (32-64) \| `function` \| `false` | How many bits of IPv6 addresses to use in default `keyGenerator` | +| [`requestPropertyName`] | `string` | Add rate limit info to the `req` object. | +| [`skip`] | `function` | Return `true` to bypass the limiter for the given request. | +| [`skipSuccessfulRequests`] | `boolean` | Uncount 1xx/2xx/3xx responses. | +| [`skipFailedRequests`] | `boolean` | Uncount 4xx/5xx responses. | +| [`requestWasSuccessful`] | `function` | Used by `skipSuccessfulRequests` and `skipFailedRequests`. | +| [`validate`] | `boolean` \| `object` | Enable or disable built-in validation checks. | +| [`logger`] | `Logger` | Custom logger | + +## Thank You + +--- + +Thanks to Mintlify for hosting the documentation at +[express-rate-limit.mintlify.app](https://express-rate-limit.mintlify.app) + +

+ + Create your docs today + +

+ +--- + +And thank you to everyone who's contributed to this project in any way! 🫶 + +## Issues and Contributing + +If you encounter a bug or want to see something added/changed, please go ahead +and +[open an issue](https://github.com/express-rate-limit/express-rate-limit/issues/new)! +If you need help with something, feel free to +[start a discussion](https://github.com/express-rate-limit/express-rate-limit/discussions/new)! + +If you wish to contribute to the library, thanks! First, please read +[the contributing guide](https://express-rate-limit.mintlify.app/guides/contributing). +Then you can pick up any issue and fix/implement it! + +## License + +MIT © [Nathan Friedly](http://nfriedly.com/), +[Vedant K](https://github.com/gamemaker1) + +[`windowMs`]: + https://express-rate-limit.mintlify.app/reference/configuration#windowms +[`limit`]: https://express-rate-limit.mintlify.app/reference/configuration#limit +[`message`]: + https://express-rate-limit.mintlify.app/reference/configuration#message +[`statusCode`]: + https://express-rate-limit.mintlify.app/reference/configuration#statuscode +[`handler`]: + https://express-rate-limit.mintlify.app/reference/configuration#handler +[`legacyHeaders`]: + https://express-rate-limit.mintlify.app/reference/configuration#legacyheaders +[`standardHeaders`]: + https://express-rate-limit.mintlify.app/reference/configuration#standardheaders +[`identifier`]: + https://express-rate-limit.mintlify.app/reference/configuration#identifier +[`store`]: https://express-rate-limit.mintlify.app/reference/configuration#store +[`passOnStoreError`]: + https://express-rate-limit.mintlify.app/reference/configuration#passonstoreerror +[`keyGenerator`]: + https://express-rate-limit.mintlify.app/reference/configuration#keygenerator +[`ipv6Subnet`]: + https://express-rate-limit.mintlify.app/reference/configuration#ipv6subnet +[`requestPropertyName`]: + https://express-rate-limit.mintlify.app/reference/configuration#requestpropertyname +[`skip`]: https://express-rate-limit.mintlify.app/reference/configuration#skip +[`skipSuccessfulRequests`]: + https://express-rate-limit.mintlify.app/reference/configuration#skipsuccessfulrequests +[`skipFailedRequests`]: + https://express-rate-limit.mintlify.app/reference/configuration#skipfailedrequests +[`requestWasSuccessful`]: + https://express-rate-limit.mintlify.app/reference/configuration#requestwassuccessful +[`validate`]: + https://express-rate-limit.mintlify.app/reference/configuration#validate +[`logger`]: + https://express-rate-limit.mintlify.app/reference/configuration#logger diff --git a/tools/ui/node_modules/express-rate-limit/tsconfig.json b/tools/ui/node_modules/express-rate-limit/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..52b6ff1746cccad7e4b0b6fd89cda638395081dc --- /dev/null +++ b/tools/ui/node_modules/express-rate-limit/tsconfig.json @@ -0,0 +1,8 @@ +{ + "include": ["source/"], + "exclude": ["node_modules/"], + "extends": "@express-rate-limit/tsconfig", + "compilerOptions": { + "target": "ES2020" + } +} diff --git a/tools/ui/node_modules/express/LICENSE b/tools/ui/node_modules/express/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..aa927e44e31d486f807634887662efa39256bf84 --- /dev/null +++ b/tools/ui/node_modules/express/LICENSE @@ -0,0 +1,24 @@ +(The MIT License) + +Copyright (c) 2009-2014 TJ Holowaychuk +Copyright (c) 2013-2014 Roman Shtylman +Copyright (c) 2014-2015 Douglas Christopher Wilson + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/express/Readme.md b/tools/ui/node_modules/express/Readme.md new file mode 100644 index 0000000000000000000000000000000000000000..4c5b6f757f46af739bceddb1092b5afede92b3e4 --- /dev/null +++ b/tools/ui/node_modules/express/Readme.md @@ -0,0 +1,276 @@ +[![Express Logo](https://i.cloudup.com/zfY6lL7eFa-3000x3000.png)](https://expressjs.com/) + +**Fast, unopinionated, minimalist web framework for [Node.js](https://nodejs.org).** + +**This project has a [Code of Conduct].** + +## Table of contents + +- [Table of contents](#table-of-contents) +- [Installation](#installation) +- [Features](#features) +- [Docs \& Community](#docs--community) +- [Quick Start](#quick-start) +- [Philosophy](#philosophy) +- [Examples](#examples) +- [Contributing](#contributing) + - [Security Issues](#security-issues) + - [Running Tests](#running-tests) +- [Current project team members](#current-project-team-members) + - [TC (Technical Committee)](#tc-technical-committee) + - [TC emeriti members](#tc-emeriti-members) + - [Triagers](#triagers) + - [Emeritus Triagers](#emeritus-triagers) +- [License](#license) + + +[![NPM Version][npm-version-image]][npm-url] +[![NPM Downloads][npm-downloads-image]][npm-downloads-url] +[![Linux Build][github-actions-ci-image]][github-actions-ci-url] +[![Test Coverage][coveralls-image]][coveralls-url] +[![OpenSSF Scorecard Badge][ossf-scorecard-badge]][ossf-scorecard-visualizer] + + +```js +import express from 'express' + +const app = express() + +app.get('/', (req, res) => { + res.send('Hello World') +}) + +app.listen(3000, () => { + console.log('Server is running on http://localhost:3000') +}) +``` + +## Installation + +This is a [Node.js](https://nodejs.org/en/) module available through the +[npm registry](https://www.npmjs.com/). + +Before installing, [download and install Node.js](https://nodejs.org/en/download/). +Node.js 18 or higher is required. + +If this is a brand new project, make sure to create a `package.json` first with +the [`npm init` command](https://docs.npmjs.com/creating-a-package-json-file). + +Installation is done using the +[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally): + +```bash +npm install express +``` + +Follow [our installing guide](https://expressjs.com/en/starter/installing.html) +for more information. + +## Features + + * Robust routing + * Focus on high performance + * Super-high test coverage + * HTTP helpers (redirection, caching, etc) + * View system supporting 14+ template engines + * Content negotiation + * Executable for generating applications quickly + +## Docs & Community + + * [Website and Documentation](https://expressjs.com/) - [[website repo](https://github.com/expressjs/expressjs.com)] + * [GitHub Organization](https://github.com/expressjs) for Official Middleware & Modules + * [Github Discussions](https://github.com/expressjs/discussions) for discussion on the development and usage of Express + +**PROTIP** Be sure to read the [migration guide to v5](https://expressjs.com/en/guide/migrating-5) + +## Quick Start + + The quickest way to get started with express is to utilize the executable [`express(1)`](https://github.com/expressjs/generator) to generate an application as shown below: + + Install the executable. The executable's major version will match Express's: + +```bash +npm install -g express-generator@4 +``` + + Create the app: + +```bash +express /tmp/foo && cd /tmp/foo +``` + + Install dependencies: + +```bash +npm install +``` + + Start the server: + +```bash +npm start +``` + + View the website at: http://localhost:3000 + +## Philosophy + + The Express philosophy is to provide small, robust tooling for HTTP servers, making + it a great solution for single page applications, websites, hybrids, or public + HTTP APIs. + + Express does not force you to use any specific ORM or template engine. With support for over + 14 template engines via [@ladjs/consolidate](https://github.com/ladjs/consolidate), + you can quickly craft your perfect framework. + +## Examples + + To view the examples, clone the Express repository: + +```bash +git clone https://github.com/expressjs/express.git --depth 1 && cd express +``` + + Then install the dependencies: + +```bash +npm install +``` + + Then run whichever example you want: + +```bash +node examples/content-negotiation +``` + +## Contributing + +The Express.js project welcomes all constructive contributions. Contributions take many forms, +from code for bug fixes and enhancements, to additions and fixes to documentation, additional +tests, triaging incoming pull requests and issues, and more! + +See the [Contributing Guide] for more technical details on contributing. + +### Security Issues + +If you discover a security vulnerability in Express, please see [Security Policies and Procedures](SECURITY.md). + +### Running Tests + +To run the test suite, first install the dependencies: + +```bash +npm install +``` + +Then run `npm test`: + +```bash +npm test +``` + +## Current project team members + +For information about the governance of the express.js project, see [GOVERNANCE.md](https://github.com/expressjs/discussions/blob/HEAD/docs/GOVERNANCE.md). + +The original author of Express is [TJ Holowaychuk](https://github.com/tj) + +[List of all contributors](https://github.com/expressjs/express/graphs/contributors) + +### TC (Technical Committee) + +* [UlisesGascon](https://github.com/UlisesGascon) - **Ulises Gascón** (he/him) +* [jonchurch](https://github.com/jonchurch) - **Jon Church** +* [wesleytodd](https://github.com/wesleytodd) - **Wes Todd** +* [LinusU](https://github.com/LinusU) - **Linus Unnebäck** +* [blakeembrey](https://github.com/blakeembrey) - **Blake Embrey** +* [sheplu](https://github.com/sheplu) - **Jean Burellier** +* [crandmck](https://github.com/crandmck) - **Rand McKinney** +* [ctcpip](https://github.com/ctcpip) - **Chris de Almeida** + +
+TC emeriti members + +#### TC emeriti members + + * [dougwilson](https://github.com/dougwilson) - **Douglas Wilson** + * [hacksparrow](https://github.com/hacksparrow) - **Hage Yaapa** + * [jonathanong](https://github.com/jonathanong) - **jongleberry** + * [niftylettuce](https://github.com/niftylettuce) - **niftylettuce** + * [troygoode](https://github.com/troygoode) - **Troy Goode** +
+ + +### Triagers + +* [aravindvnair99](https://github.com/aravindvnair99) - **Aravind Nair** +* [bjohansebas](https://github.com/bjohansebas) - **Sebastian Beltran** +* [carpasse](https://github.com/carpasse) - **Carlos Serrano** +* [CBID2](https://github.com/CBID2) - **Christine Belzie** +* [UlisesGascon](https://github.com/UlisesGascon) - **Ulises Gascón** (he/him) +* [IamLizu](https://github.com/IamLizu) - **S M Mahmudul Hasan** (he/him) +* [Phillip9587](https://github.com/Phillip9587) - **Phillip Barta** +* [efekrskl](https://github.com/efekrskl) - **Efe Karasakal** + + +
+Triagers emeriti members + +#### Emeritus Triagers + + * [AuggieH](https://github.com/AuggieH) - **Auggie Hudak** + * [G-Rath](https://github.com/G-Rath) - **Gareth Jones** + * [MohammadXroid](https://github.com/MohammadXroid) - **Mohammad Ayashi** + * [NawafSwe](https://github.com/NawafSwe) - **Nawaf Alsharqi** + * [NotMoni](https://github.com/NotMoni) - **Moni** + * [VigneshMurugan](https://github.com/VigneshMurugan) - **Vignesh Murugan** + * [davidmashe](https://github.com/davidmashe) - **David Ashe** + * [digitaIfabric](https://github.com/digitaIfabric) - **David** + * [e-l-i-s-e](https://github.com/e-l-i-s-e) - **Elise Bonner** + * [fed135](https://github.com/fed135) - **Frederic Charette** + * [firmanJS](https://github.com/firmanJS) - **Firman Abdul Hakim** + * [getspooky](https://github.com/getspooky) - **Yasser Ameur** + * [ghinks](https://github.com/ghinks) - **Glenn** + * [ghousemohamed](https://github.com/ghousemohamed) - **Ghouse Mohamed** + * [gireeshpunathil](https://github.com/gireeshpunathil) - **Gireesh Punathil** + * [jake32321](https://github.com/jake32321) - **Jake Reed** + * [jonchurch](https://github.com/jonchurch) - **Jon Church** + * [lekanikotun](https://github.com/lekanikotun) - **Troy Goode** + * [marsonya](https://github.com/marsonya) - **Lekan Ikotun** + * [mastermatt](https://github.com/mastermatt) - **Matt R. Wilson** + * [maxakuru](https://github.com/maxakuru) - **Max Edell** + * [mlrawlings](https://github.com/mlrawlings) - **Michael Rawlings** + * [rodion-arr](https://github.com/rodion-arr) - **Rodion Abdurakhimov** + * [sheplu](https://github.com/sheplu) - **Jean Burellier** + * [tarunyadav1](https://github.com/tarunyadav1) - **Tarun yadav** + * [tunniclm](https://github.com/tunniclm) - **Mike Tunnicliffe** + * [enyoghasim](https://github.com/enyoghasim) - **David Enyoghasim** + * [0ss](https://github.com/0ss) - **Salah** + * [import-brain](https://github.com/import-brain) - **Eric Cheng** (he/him) + * [dakshkhetan](https://github.com/dakshkhetan) - **Daksh Khetan** (he/him) + * [lucasraziel](https://github.com/lucasraziel) - **Lucas Soares Do Rego** + * [mertcanaltin](https://github.com/mertcanaltin) - **Mert Can Altin** + * [dpopp07](https://github.com/dpopp07) - **Dustin Popp** + * [Sushmeet](https://github.com/Sushmeet) - **Sushmeet Sunger** + * [3imed-jaberi](https://github.com/3imed-jaberi) - **Imed Jaberi** + +
+ + +## License + + [MIT](LICENSE) + +[coveralls-image]: https://img.shields.io/coverallsCoverage/github/expressjs/express?branch=master +[coveralls-url]: https://coveralls.io/r/expressjs/express?branch=master +[github-actions-ci-image]: https://img.shields.io/github/actions/workflow/status/expressjs/express/ci.yml?branch=master&label=ci +[github-actions-ci-url]: https://github.com/expressjs/express/actions/workflows/ci.yml +[npm-downloads-image]: https://img.shields.io/npm/dm/express +[npm-downloads-url]: https://npmcharts.com/compare/express?minimal=true +[npm-url]: https://npmjs.org/package/express +[npm-version-image]: https://img.shields.io/npm/v/express +[ossf-scorecard-badge]: https://api.scorecard.dev/projects/github.com/expressjs/express/badge +[ossf-scorecard-visualizer]: https://ossf.github.io/scorecard-visualizer/#/projects/github.com/expressjs/express +[Code of Conduct]: https://github.com/expressjs/.github/blob/HEAD/CODE_OF_CONDUCT.md +[Contributing Guide]: https://github.com/expressjs/.github/blob/HEAD/CONTRIBUTING.md diff --git a/tools/ui/node_modules/express/index.js b/tools/ui/node_modules/express/index.js new file mode 100644 index 0000000000000000000000000000000000000000..d219b0c878dc6136eb2096cffa140bf6bf2b8e9c --- /dev/null +++ b/tools/ui/node_modules/express/index.js @@ -0,0 +1,11 @@ +/*! + * express + * Copyright(c) 2009-2013 TJ Holowaychuk + * Copyright(c) 2013 Roman Shtylman + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict'; + +module.exports = require('./lib/express'); diff --git a/tools/ui/node_modules/express/lib/application.js b/tools/ui/node_modules/express/lib/application.js new file mode 100644 index 0000000000000000000000000000000000000000..838b882aaaedc6200a38e3bb06f4bffaf85cad7a --- /dev/null +++ b/tools/ui/node_modules/express/lib/application.js @@ -0,0 +1,631 @@ +/*! + * express + * Copyright(c) 2009-2013 TJ Holowaychuk + * Copyright(c) 2013 Roman Shtylman + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict'; + +/** + * Module dependencies. + * @private + */ + +var finalhandler = require('finalhandler'); +var debug = require('debug')('express:application'); +var View = require('./view'); +var http = require('node:http'); +var methods = require('./utils').methods; +var compileETag = require('./utils').compileETag; +var compileQueryParser = require('./utils').compileQueryParser; +var compileTrust = require('./utils').compileTrust; +var resolve = require('node:path').resolve; +var once = require('once') +var Router = require('router'); + +/** + * Module variables. + * @private + */ + +var slice = Array.prototype.slice; +var flatten = Array.prototype.flat; + +/** + * Application prototype. + */ + +var app = exports = module.exports = {}; + +/** + * Variable for trust proxy inheritance back-compat + * @private + */ + +var trustProxyDefaultSymbol = '@@symbol:trust_proxy_default'; + +/** + * Initialize the server. + * + * - setup default configuration + * - setup default middleware + * - setup route reflection methods + * + * @private + */ + +app.init = function init() { + var router = null; + + this.cache = Object.create(null); + this.engines = Object.create(null); + this.settings = Object.create(null); + + this.defaultConfiguration(); + + // Setup getting to lazily add base router + Object.defineProperty(this, 'router', { + configurable: true, + enumerable: true, + get: function getrouter() { + if (router === null) { + router = new Router({ + caseSensitive: this.enabled('case sensitive routing'), + strict: this.enabled('strict routing') + }); + } + + return router; + } + }); +}; + +/** + * Initialize application configuration. + * @private + */ + +app.defaultConfiguration = function defaultConfiguration() { + var env = process.env.NODE_ENV || 'development'; + + // default settings + this.enable('x-powered-by'); + this.set('etag', 'weak'); + this.set('env', env); + this.set('query parser', 'simple') + this.set('subdomain offset', 2); + this.set('trust proxy', false); + + // trust proxy inherit back-compat + Object.defineProperty(this.settings, trustProxyDefaultSymbol, { + configurable: true, + value: true + }); + + debug('booting in %s mode', env); + + this.on('mount', function onmount(parent) { + // inherit trust proxy + if (this.settings[trustProxyDefaultSymbol] === true + && typeof parent.settings['trust proxy fn'] === 'function') { + delete this.settings['trust proxy']; + delete this.settings['trust proxy fn']; + } + + // inherit protos + Object.setPrototypeOf(this.request, parent.request) + Object.setPrototypeOf(this.response, parent.response) + Object.setPrototypeOf(this.engines, parent.engines) + Object.setPrototypeOf(this.settings, parent.settings) + }); + + // setup locals + this.locals = Object.create(null); + + // top-most app is mounted at / + this.mountpath = '/'; + + // default locals + this.locals.settings = this.settings; + + // default configuration + this.set('view', View); + this.set('views', resolve('views')); + this.set('jsonp callback name', 'callback'); + + if (env === 'production') { + this.enable('view cache'); + } +}; + +/** + * Dispatch a req, res pair into the application. Starts pipeline processing. + * + * If no callback is provided, then default error handlers will respond + * in the event of an error bubbling through the stack. + * + * @private + */ + +app.handle = function handle(req, res, callback) { + // final handler + var done = callback || finalhandler(req, res, { + env: this.get('env'), + onerror: logerror.bind(this) + }); + + // set powered by header + if (this.enabled('x-powered-by')) { + res.setHeader('X-Powered-By', 'Express'); + } + + // set circular references + req.res = res; + res.req = req; + + // alter the prototypes + Object.setPrototypeOf(req, this.request) + Object.setPrototypeOf(res, this.response) + + // setup locals + if (!res.locals) { + res.locals = Object.create(null); + } + + this.router.handle(req, res, done); +}; + +/** + * Proxy `Router#use()` to add middleware to the app router. + * See Router#use() documentation for details. + * + * If the _fn_ parameter is an express app, then it will be + * mounted at the _route_ specified. + * + * @public + */ + +app.use = function use(fn) { + var offset = 0; + var path = '/'; + + // default path to '/' + // disambiguate app.use([fn]) + if (typeof fn !== 'function') { + var arg = fn; + + while (Array.isArray(arg) && arg.length !== 0) { + arg = arg[0]; + } + + // first arg is the path + if (typeof arg !== 'function') { + offset = 1; + path = fn; + } + } + + var fns = flatten.call(slice.call(arguments, offset), Infinity); + + if (fns.length === 0) { + throw new TypeError('app.use() requires a middleware function') + } + + // get router + var router = this.router; + + fns.forEach(function (fn) { + // non-express app + if (!fn || !fn.handle || !fn.set) { + return router.use(path, fn); + } + + debug('.use app under %s', path); + fn.mountpath = path; + fn.parent = this; + + // restore .app property on req and res + router.use(path, function mounted_app(req, res, next) { + var orig = req.app; + fn.handle(req, res, function (err) { + Object.setPrototypeOf(req, orig.request) + Object.setPrototypeOf(res, orig.response) + next(err); + }); + }); + + // mounted an app + fn.emit('mount', this); + }, this); + + return this; +}; + +/** + * Proxy to the app `Router#route()` + * Returns a new `Route` instance for the _path_. + * + * Routes are isolated middleware stacks for specific paths. + * See the Route api docs for details. + * + * @public + */ + +app.route = function route(path) { + return this.router.route(path); +}; + +/** + * Register the given template engine callback `fn` + * as `ext`. + * + * By default will `require()` the engine based on the + * file extension. For example if you try to render + * a "foo.ejs" file Express will invoke the following internally: + * + * app.engine('ejs', require('ejs').__express); + * + * For engines that do not provide `.__express` out of the box, + * or if you wish to "map" a different extension to the template engine + * you may use this method. For example mapping the EJS template engine to + * ".html" files: + * + * app.engine('html', require('ejs').renderFile); + * + * In this case EJS provides a `.renderFile()` method with + * the same signature that Express expects: `(path, options, callback)`, + * though note that it aliases this method as `ejs.__express` internally + * so if you're using ".ejs" extensions you don't need to do anything. + * + * Some template engines do not follow this convention, the + * [Consolidate.js](https://github.com/tj/consolidate.js) + * library was created to map all of node's popular template + * engines to follow this convention, thus allowing them to + * work seamlessly within Express. + * + * @param {String} ext + * @param {Function} fn + * @return {app} for chaining + * @public + */ + +app.engine = function engine(ext, fn) { + if (typeof fn !== 'function') { + throw new Error('callback function required'); + } + + // get file extension + var extension = ext[0] !== '.' + ? '.' + ext + : ext; + + // store engine + this.engines[extension] = fn; + + return this; +}; + +/** + * Proxy to `Router#param()` with one added api feature. The _name_ parameter + * can be an array of names. + * + * See the Router#param() docs for more details. + * + * @param {String|Array} name + * @param {Function} fn + * @return {app} for chaining + * @public + */ + +app.param = function param(name, fn) { + if (Array.isArray(name)) { + for (var i = 0; i < name.length; i++) { + this.param(name[i], fn); + } + + return this; + } + + this.router.param(name, fn); + + return this; +}; + +/** + * Assign `setting` to `val`, or return `setting`'s value. + * + * app.set('foo', 'bar'); + * app.set('foo'); + * // => "bar" + * + * Mounted servers inherit their parent server's settings. + * + * @param {String} setting + * @param {*} [val] + * @return {Server} for chaining + * @public + */ + +app.set = function set(setting, val) { + if (arguments.length === 1) { + // app.get(setting) + return this.settings[setting]; + } + + debug('set "%s" to %o', setting, val); + + // set value + this.settings[setting] = val; + + // trigger matched settings + switch (setting) { + case 'etag': + this.set('etag fn', compileETag(val)); + break; + case 'query parser': + this.set('query parser fn', compileQueryParser(val)); + break; + case 'trust proxy': + this.set('trust proxy fn', compileTrust(val)); + + // trust proxy inherit back-compat + Object.defineProperty(this.settings, trustProxyDefaultSymbol, { + configurable: true, + value: false + }); + + break; + } + + return this; +}; + +/** + * Return the app's absolute pathname + * based on the parent(s) that have + * mounted it. + * + * For example if the application was + * mounted as "/admin", which itself + * was mounted as "/blog" then the + * return value would be "/blog/admin". + * + * @return {String} + * @private + */ + +app.path = function path() { + return this.parent + ? this.parent.path() + this.mountpath + : ''; +}; + +/** + * Check if `setting` is enabled (truthy). + * + * app.enabled('foo') + * // => false + * + * app.enable('foo') + * app.enabled('foo') + * // => true + * + * @param {String} setting + * @return {Boolean} + * @public + */ + +app.enabled = function enabled(setting) { + return Boolean(this.set(setting)); +}; + +/** + * Check if `setting` is disabled. + * + * app.disabled('foo') + * // => true + * + * app.enable('foo') + * app.disabled('foo') + * // => false + * + * @param {String} setting + * @return {Boolean} + * @public + */ + +app.disabled = function disabled(setting) { + return !this.set(setting); +}; + +/** + * Enable `setting`. + * + * @param {String} setting + * @return {app} for chaining + * @public + */ + +app.enable = function enable(setting) { + return this.set(setting, true); +}; + +/** + * Disable `setting`. + * + * @param {String} setting + * @return {app} for chaining + * @public + */ + +app.disable = function disable(setting) { + return this.set(setting, false); +}; + +/** + * Delegate `.VERB(...)` calls to `router.VERB(...)`. + */ + +methods.forEach(function (method) { + app[method] = function (path) { + if (method === 'get' && arguments.length === 1) { + // app.get(setting) + return this.set(path); + } + + var route = this.route(path); + route[method].apply(route, slice.call(arguments, 1)); + return this; + }; +}); + +/** + * Special-cased "all" method, applying the given route `path`, + * middleware, and callback to _every_ HTTP method. + * + * @param {String} path + * @param {Function} ... + * @return {app} for chaining + * @public + */ + +app.all = function all(path) { + var route = this.route(path); + var args = slice.call(arguments, 1); + + for (var i = 0; i < methods.length; i++) { + route[methods[i]].apply(route, args); + } + + return this; +}; + +/** + * Render the given view `name` name with `options` + * and a callback accepting an error and the + * rendered template string. + * + * Example: + * + * app.render('email', { name: 'Tobi' }, function(err, html){ + * // ... + * }) + * + * @param {String} name + * @param {Object|Function} options or fn + * @param {Function} callback + * @public + */ + +app.render = function render(name, options, callback) { + var cache = this.cache; + var done = callback; + var engines = this.engines; + var opts = options; + var view; + + // support callback function as second arg + if (typeof options === 'function') { + done = options; + opts = {}; + } + + // merge options + var renderOptions = { ...this.locals, ...opts._locals, ...opts }; + + // set .cache unless explicitly provided + if (renderOptions.cache == null) { + renderOptions.cache = this.enabled('view cache'); + } + + // primed cache + if (renderOptions.cache) { + view = cache[name]; + } + + // view + if (!view) { + var View = this.get('view'); + + view = new View(name, { + defaultEngine: this.get('view engine'), + root: this.get('views'), + engines: engines + }); + + if (!view.path) { + var dirs = Array.isArray(view.root) && view.root.length > 1 + ? 'directories "' + view.root.slice(0, -1).join('", "') + '" or "' + view.root[view.root.length - 1] + '"' + : 'directory "' + view.root + '"' + var err = new Error('Failed to lookup view "' + name + '" in views ' + dirs); + err.view = view; + return done(err); + } + + // prime the cache + if (renderOptions.cache) { + cache[name] = view; + } + } + + // render + tryRender(view, renderOptions, done); +}; + +/** + * Listen for connections. + * + * A node `http.Server` is returned, with this + * application (which is a `Function`) as its + * callback. If you wish to create both an HTTP + * and HTTPS server you may do so with the "http" + * and "https" modules as shown here: + * + * var http = require('node:http') + * , https = require('node:https') + * , express = require('express') + * , app = express(); + * + * http.createServer(app).listen(80); + * https.createServer({ ... }, app).listen(443); + * + * @return {http.Server} + * @public + */ + +app.listen = function listen() { + var server = http.createServer(this) + var args = slice.call(arguments) + if (typeof args[args.length - 1] === 'function') { + var done = args[args.length - 1] = once(args[args.length - 1]) + server.once('error', done) + } + return server.listen.apply(server, args) +} + +/** + * Log error using console.error. + * + * @param {Error} err + * @private + */ + +function logerror(err) { + /* istanbul ignore next */ + if (this.get('env') !== 'test') console.error(err.stack || err.toString()); +} + +/** + * Try rendering a view. + * @private + */ + +function tryRender(view, options, callback) { + try { + view.render(options, callback); + } catch (err) { + callback(err); + } +} diff --git a/tools/ui/node_modules/express/lib/express.js b/tools/ui/node_modules/express/lib/express.js new file mode 100644 index 0000000000000000000000000000000000000000..2d502eb54e4d7e2f2374494e32071d9416d56418 --- /dev/null +++ b/tools/ui/node_modules/express/lib/express.js @@ -0,0 +1,81 @@ +/*! + * express + * Copyright(c) 2009-2013 TJ Holowaychuk + * Copyright(c) 2013 Roman Shtylman + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict'; + +/** + * Module dependencies. + */ + +var bodyParser = require('body-parser') +var EventEmitter = require('node:events').EventEmitter; +var mixin = require('merge-descriptors'); +var proto = require('./application'); +var Router = require('router'); +var req = require('./request'); +var res = require('./response'); + +/** + * Expose `createApplication()`. + */ + +exports = module.exports = createApplication; + +/** + * Create an express application. + * + * @return {Function} + * @api public + */ + +function createApplication() { + var app = function(req, res, next) { + app.handle(req, res, next); + }; + + mixin(app, EventEmitter.prototype, false); + mixin(app, proto, false); + + // expose the prototype that will get set on requests + app.request = Object.create(req, { + app: { configurable: true, enumerable: true, writable: true, value: app } + }) + + // expose the prototype that will get set on responses + app.response = Object.create(res, { + app: { configurable: true, enumerable: true, writable: true, value: app } + }) + + app.init(); + return app; +} + +/** + * Expose the prototypes. + */ + +exports.application = proto; +exports.request = req; +exports.response = res; + +/** + * Expose constructors. + */ + +exports.Route = Router.Route; +exports.Router = Router; + +/** + * Expose middleware + */ + +exports.json = bodyParser.json +exports.raw = bodyParser.raw +exports.static = require('serve-static'); +exports.text = bodyParser.text +exports.urlencoded = bodyParser.urlencoded diff --git a/tools/ui/node_modules/express/lib/request.js b/tools/ui/node_modules/express/lib/request.js new file mode 100644 index 0000000000000000000000000000000000000000..69990da39b6da3103d72d74bd729e3372468f82b --- /dev/null +++ b/tools/ui/node_modules/express/lib/request.js @@ -0,0 +1,514 @@ +/*! + * express + * Copyright(c) 2009-2013 TJ Holowaychuk + * Copyright(c) 2013 Roman Shtylman + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict'; + +/** + * Module dependencies. + * @private + */ + +var accepts = require('accepts'); +var isIP = require('node:net').isIP; +var typeis = require('type-is'); +var http = require('node:http'); +var fresh = require('fresh'); +var parseRange = require('range-parser'); +var parse = require('parseurl'); +var proxyaddr = require('proxy-addr'); + +/** + * Request prototype. + * @public + */ + +var req = Object.create(http.IncomingMessage.prototype) + +/** + * Module exports. + * @public + */ + +module.exports = req + +/** + * Return request header. + * + * The `Referrer` header field is special-cased, + * both `Referrer` and `Referer` are interchangeable. + * + * Examples: + * + * req.get('Content-Type'); + * // => "text/plain" + * + * req.get('content-type'); + * // => "text/plain" + * + * req.get('Something'); + * // => undefined + * + * Aliased as `req.header()`. + * + * @param {String} name + * @return {String} + * @public + */ + +req.get = +req.header = function header(name) { + if (!name) { + throw new TypeError('name argument is required to req.get'); + } + + if (typeof name !== 'string') { + throw new TypeError('name must be a string to req.get'); + } + + var lc = name.toLowerCase(); + + switch (lc) { + case 'referer': + case 'referrer': + return this.headers.referrer + || this.headers.referer; + default: + return this.headers[lc]; + } +}; + +/** + * To do: update docs. + * + * Check if the given `type(s)` is acceptable, returning + * the best match when true, otherwise `undefined`, in which + * case you should respond with 406 "Not Acceptable". + * + * The `type` value may be a single MIME type string + * such as "application/json", an extension name + * such as "json", a comma-delimited list such as "json, html, text/plain", + * an argument list such as `"json", "html", "text/plain"`, + * or an array `["json", "html", "text/plain"]`. When a list + * or array is given, the _best_ match, if any is returned. + * + * Examples: + * + * // Accept: text/html + * req.accepts('html'); + * // => "html" + * + * // Accept: text/*, application/json + * req.accepts('html'); + * // => "html" + * req.accepts('text/html'); + * // => "text/html" + * req.accepts('json, text'); + * // => "json" + * req.accepts('application/json'); + * // => "application/json" + * + * // Accept: text/*, application/json + * req.accepts('image/png'); + * req.accepts('png'); + * // => undefined + * + * // Accept: text/*;q=.5, application/json + * req.accepts(['html', 'json']); + * req.accepts('html', 'json'); + * req.accepts('html, json'); + * // => "json" + * + * @param {String|Array} type(s) + * @return {String|Array|Boolean} + * @public + */ + +req.accepts = function(){ + var accept = accepts(this); + return accept.types.apply(accept, arguments); +}; + +/** + * Check if the given `encoding`s are accepted. + * + * @param {String} ...encoding + * @return {String|Array} + * @public + */ + +req.acceptsEncodings = function(){ + var accept = accepts(this); + return accept.encodings.apply(accept, arguments); +}; + +/** + * Check if the given `charset`s are acceptable, + * otherwise you should respond with 406 "Not Acceptable". + * + * @param {String} ...charset + * @return {String|Array} + * @public + */ + +req.acceptsCharsets = function(){ + var accept = accepts(this); + return accept.charsets.apply(accept, arguments); +}; + +/** + * Check if the given `lang`s are acceptable, + * otherwise you should respond with 406 "Not Acceptable". + * + * @param {String} ...lang + * @return {String|Array} + * @public + */ + +req.acceptsLanguages = function(...languages) { + return accepts(this).languages(...languages); +}; + +/** + * Parse Range header field, capping to the given `size`. + * + * Unspecified ranges such as "0-" require knowledge of your resource length. In + * the case of a byte range this is of course the total number of bytes. If the + * Range header field is not given `undefined` is returned, `-1` when unsatisfiable, + * and `-2` when syntactically invalid. + * + * When ranges are returned, the array has a "type" property which is the type of + * range that is required (most commonly, "bytes"). Each array element is an object + * with a "start" and "end" property for the portion of the range. + * + * The "combine" option can be set to `true` and overlapping & adjacent ranges + * will be combined into a single range. + * + * NOTE: remember that ranges are inclusive, so for example "Range: users=0-3" + * should respond with 4 users when available, not 3. + * + * @param {number} size + * @param {object} [options] + * @param {boolean} [options.combine=false] + * @return {number|array} + * @public + */ + +req.range = function range(size, options) { + var range = this.get('Range'); + if (!range) return; + return parseRange(size, range, options); +}; + +/** + * Parse the query string of `req.url`. + * + * This uses the "query parser" setting to parse the raw + * string into an object. + * + * @return {String} + * @api public + */ + +defineGetter(req, 'query', function query(){ + var queryparse = this.app.get('query parser fn'); + + if (!queryparse) { + // parsing is disabled + return Object.create(null); + } + + var querystring = parse(this).query; + + return queryparse(querystring); +}); + +/** + * Check if the incoming request contains the "Content-Type" + * header field, and it contains the given mime `type`. + * + * Examples: + * + * // With Content-Type: text/html; charset=utf-8 + * req.is('html'); + * req.is('text/html'); + * req.is('text/*'); + * // => true + * + * // When Content-Type is application/json + * req.is('json'); + * req.is('application/json'); + * req.is('application/*'); + * // => true + * + * req.is('html'); + * // => false + * + * @param {String|Array} types... + * @return {String|false|null} + * @public + */ + +req.is = function is(types) { + var arr = types; + + // support flattened arguments + if (!Array.isArray(types)) { + arr = new Array(arguments.length); + for (var i = 0; i < arr.length; i++) { + arr[i] = arguments[i]; + } + } + + return typeis(this, arr); +}; + +/** + * Return the protocol string "http" or "https" + * when requested with TLS. When the "trust proxy" + * setting trusts the socket address, the + * "X-Forwarded-Proto" header field will be trusted + * and used if present. + * + * If you're running behind a reverse proxy that + * supplies https for you this may be enabled. + * + * @return {String} + * @public + */ + +defineGetter(req, 'protocol', function protocol(){ + var proto = this.socket.encrypted + ? 'https' + : 'http'; + var trust = this.app.get('trust proxy fn'); + + if (!trust(this.socket.remoteAddress, 0)) { + return proto; + } + + // Note: X-Forwarded-Proto is normally only ever a + // single value, but this is to be safe. + var header = this.get('X-Forwarded-Proto') || proto + var index = header.indexOf(',') + + return index !== -1 + ? header.substring(0, index).trim() + : header.trim() +}); + +/** + * Short-hand for: + * + * req.protocol === 'https' + * + * @return {Boolean} + * @public + */ + +defineGetter(req, 'secure', function secure(){ + return this.protocol === 'https'; +}); + +/** + * Return the remote address from the trusted proxy. + * + * The is the remote address on the socket unless + * "trust proxy" is set. + * + * @return {String} + * @public + */ + +defineGetter(req, 'ip', function ip(){ + var trust = this.app.get('trust proxy fn'); + return proxyaddr(this, trust); +}); + +/** + * When "trust proxy" is set, trusted proxy addresses + client. + * + * For example if the value were "client, proxy1, proxy2" + * you would receive the array `["client", "proxy1", "proxy2"]` + * where "proxy2" is the furthest down-stream and "proxy1" and + * "proxy2" were trusted. + * + * @return {Array} + * @public + */ + +defineGetter(req, 'ips', function ips() { + var trust = this.app.get('trust proxy fn'); + var addrs = proxyaddr.all(this, trust); + + // reverse the order (to farthest -> closest) + // and remove socket address + addrs.reverse().pop() + + return addrs +}); + +/** + * Return subdomains as an array. + * + * Subdomains are the dot-separated parts of the host before the main domain of + * the app. By default, the domain of the app is assumed to be the last two + * parts of the host. This can be changed by setting "subdomain offset". + * + * For example, if the domain is "tobi.ferrets.example.com": + * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`. + * If "subdomain offset" is 3, req.subdomains is `["tobi"]`. + * + * @return {Array} + * @public + */ + +defineGetter(req, 'subdomains', function subdomains() { + var hostname = this.hostname; + + if (!hostname) return []; + + var offset = this.app.get('subdomain offset'); + var subdomains = !isIP(hostname) + ? hostname.split('.').reverse() + : [hostname]; + + return subdomains.slice(offset); +}); + +/** + * Short-hand for `url.parse(req.url).pathname`. + * + * @return {String} + * @public + */ + +defineGetter(req, 'path', function path() { + return parse(this).pathname; +}); + +/** + * Parse the "Host" header field to a host. + * + * When the "trust proxy" setting trusts the socket + * address, the "X-Forwarded-Host" header field will + * be trusted. + * + * @return {String} + * @public + */ + +defineGetter(req, 'host', function host(){ + var trust = this.app.get('trust proxy fn'); + var val = this.get('X-Forwarded-Host'); + + if (!val || !trust(this.socket.remoteAddress, 0)) { + val = this.get('Host'); + } else if (val.indexOf(',') !== -1) { + // Note: X-Forwarded-Host is normally only ever a + // single value, but this is to be safe. + val = val.substring(0, val.indexOf(',')).trimRight() + } + + return val || undefined; +}); + +/** + * Parse the "Host" header field to a hostname. + * + * When the "trust proxy" setting trusts the socket + * address, the "X-Forwarded-Host" header field will + * be trusted. + * + * @return {String} + * @api public + */ + +defineGetter(req, 'hostname', function hostname(){ + var host = this.host; + + if (!host) return; + + // IPv6 literal support + var offset = host[0] === '[' + ? host.indexOf(']') + 1 + : 0; + var index = host.indexOf(':', offset); + + return index !== -1 + ? host.substring(0, index) + : host; +}); + +/** + * Check if the request is fresh, aka + * Last-Modified or the ETag + * still match. + * + * @return {Boolean} + * @public + */ + +defineGetter(req, 'fresh', function(){ + var method = this.method; + var res = this.res + var status = res.statusCode + + // GET or HEAD for weak freshness validation only + if ('GET' !== method && 'HEAD' !== method) return false; + + // 2xx or 304 as per rfc2616 14.26 + if ((status >= 200 && status < 300) || 304 === status) { + return fresh(this.headers, { + 'etag': res.get('ETag'), + 'last-modified': res.get('Last-Modified') + }) + } + + return false; +}); + +/** + * Check if the request is stale, aka + * "Last-Modified" and / or the "ETag" for the + * resource has changed. + * + * @return {Boolean} + * @public + */ + +defineGetter(req, 'stale', function stale(){ + return !this.fresh; +}); + +/** + * Check if the request was an _XMLHttpRequest_. + * + * @return {Boolean} + * @public + */ + +defineGetter(req, 'xhr', function xhr(){ + var val = this.get('X-Requested-With') || ''; + return val.toLowerCase() === 'xmlhttprequest'; +}); + +/** + * Helper function for creating a getter on an object. + * + * @param {Object} obj + * @param {String} name + * @param {Function} getter + * @private + */ +function defineGetter(obj, name, getter) { + Object.defineProperty(obj, name, { + configurable: true, + enumerable: true, + get: getter + }); +} diff --git a/tools/ui/node_modules/express/lib/response.js b/tools/ui/node_modules/express/lib/response.js new file mode 100644 index 0000000000000000000000000000000000000000..7a2f0ecce5658191e8670ab943d4f16655c279fc --- /dev/null +++ b/tools/ui/node_modules/express/lib/response.js @@ -0,0 +1,1053 @@ +/*! + * express + * Copyright(c) 2009-2013 TJ Holowaychuk + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict'; + +/** + * Module dependencies. + * @private + */ + +var contentDisposition = require('content-disposition'); +var createError = require('http-errors') +var deprecate = require('depd')('express'); +var encodeUrl = require('encodeurl'); +var escapeHtml = require('escape-html'); +var http = require('node:http'); +var onFinished = require('on-finished'); +var mime = require('mime-types') +var path = require('node:path'); +var pathIsAbsolute = require('node:path').isAbsolute; +var statuses = require('statuses') +var sign = require('cookie-signature').sign; +var normalizeType = require('./utils').normalizeType; +var normalizeTypes = require('./utils').normalizeTypes; +var setCharset = require('./utils').setCharset; +var cookie = require('cookie'); +var send = require('send'); +var extname = path.extname; +var resolve = path.resolve; +var vary = require('vary'); +const { Buffer } = require('node:buffer'); + +/** + * Response prototype. + * @public + */ + +var res = Object.create(http.ServerResponse.prototype) + +/** + * Module exports. + * @public + */ + +module.exports = res + +/** + * Set the HTTP status code for the response. + * + * Expects an integer value between 100 and 999 inclusive. + * Throws an error if the provided status code is not an integer or if it's outside the allowable range. + * + * @param {number} code - The HTTP status code to set. + * @return {ServerResponse} - Returns itself for chaining methods. + * @throws {TypeError} If `code` is not an integer. + * @throws {RangeError} If `code` is outside the range 100 to 999. + * @public + */ + +res.status = function status(code) { + // Check if the status code is not an integer + if (!Number.isInteger(code)) { + throw new TypeError(`Invalid status code: ${JSON.stringify(code)}. Status code must be an integer.`); + } + // Check if the status code is outside of Node's valid range + if (code < 100 || code > 999) { + throw new RangeError(`Invalid status code: ${JSON.stringify(code)}. Status code must be greater than 99 and less than 1000.`); + } + + this.statusCode = code; + return this; +}; + +/** + * Set Link header field with the given `links`. + * + * Examples: + * + * res.links({ + * next: 'http://api.example.com/users?page=2', + * last: 'http://api.example.com/users?page=5', + * pages: [ + * 'http://api.example.com/users?page=1', + * 'http://api.example.com/users?page=2' + * ] + * }); + * + * @param {Object} links + * @return {ServerResponse} + * @public + */ + +res.links = function(links) { + var link = this.get('Link') || ''; + if (link) link += ', '; + return this.set('Link', link + Object.keys(links).map(function(rel) { + // Allow multiple links if links[rel] is an array + if (Array.isArray(links[rel])) { + return links[rel].map(function (singleLink) { + return `<${singleLink}>; rel="${rel}"`; + }).join(', '); + } else { + return `<${links[rel]}>; rel="${rel}"`; + } + }).join(', ')); +}; + +/** + * Send a response. + * + * Examples: + * + * res.send(Buffer.from('wahoo')); + * res.send({ some: 'json' }); + * res.send('

some html

'); + * + * @param {string|number|boolean|object|Buffer} body + * @public + */ + +res.send = function send(body) { + var chunk = body; + var encoding; + var req = this.req; + var type; + + // settings + var app = this.app; + + switch (typeof chunk) { + // string defaulting to html + case 'string': + if (!this.get('Content-Type')) { + this.type('html'); + } + break; + case 'boolean': + case 'number': + case 'object': + if (chunk === null) { + chunk = ''; + } else if (ArrayBuffer.isView(chunk)) { + if (!this.get('Content-Type')) { + this.type('bin'); + } + } else { + return this.json(chunk); + } + break; + } + + // write strings in utf-8 + if (typeof chunk === 'string') { + encoding = 'utf8'; + type = this.get('Content-Type'); + + // reflect this in content-type + if (typeof type === 'string') { + this.set('Content-Type', setCharset(type, 'utf-8')); + } + } + + // determine if ETag should be generated + var etagFn = app.get('etag fn') + var generateETag = !this.get('ETag') && typeof etagFn === 'function' + + // populate Content-Length + var len + if (chunk !== undefined) { + if (Buffer.isBuffer(chunk)) { + // get length of Buffer + len = chunk.length + } else if (!generateETag && chunk.length < 1000) { + // just calculate length when no ETag + small chunk + len = Buffer.byteLength(chunk, encoding) + } else { + // convert chunk to Buffer and calculate + chunk = Buffer.from(chunk, encoding) + encoding = undefined; + len = chunk.length + } + + this.set('Content-Length', len); + } + + // populate ETag + var etag; + if (generateETag && len !== undefined) { + if ((etag = etagFn(chunk, encoding))) { + this.set('ETag', etag); + } + } + + // freshness + if (req.fresh) this.status(304); + + // strip irrelevant headers + if (204 === this.statusCode || 304 === this.statusCode) { + this.removeHeader('Content-Type'); + this.removeHeader('Content-Length'); + this.removeHeader('Transfer-Encoding'); + chunk = ''; + } + + // alter headers for 205 + if (this.statusCode === 205) { + this.set('Content-Length', '0') + this.removeHeader('Transfer-Encoding') + chunk = '' + } + + if (req.method === 'HEAD') { + // skip body for HEAD + this.end(); + } else { + // respond + this.end(chunk, encoding); + } + + return this; +}; + +/** + * Send JSON response. + * + * Examples: + * + * res.json(null); + * res.json({ user: 'tj' }); + * + * @param {string|number|boolean|object} obj + * @public + */ + +res.json = function json(obj) { + // settings + var app = this.app; + var escape = app.get('json escape') + var replacer = app.get('json replacer'); + var spaces = app.get('json spaces'); + var body = stringify(obj, replacer, spaces, escape) + + // content-type + if (!this.get('Content-Type')) { + this.set('Content-Type', 'application/json'); + } + + return this.send(body); +}; + +/** + * Send JSON response with JSONP callback support. + * + * Examples: + * + * res.jsonp(null); + * res.jsonp({ user: 'tj' }); + * + * @param {string|number|boolean|object} obj + * @public + */ + +res.jsonp = function jsonp(obj) { + // settings + var app = this.app; + var escape = app.get('json escape') + var replacer = app.get('json replacer'); + var spaces = app.get('json spaces'); + var body = stringify(obj, replacer, spaces, escape) + var callback = this.req.query[app.get('jsonp callback name')]; + + // content-type + if (!this.get('Content-Type')) { + this.set('X-Content-Type-Options', 'nosniff'); + this.set('Content-Type', 'application/json'); + } + + // fixup callback + if (Array.isArray(callback)) { + callback = callback[0]; + } + + // jsonp + if (typeof callback === 'string' && callback.length !== 0) { + this.set('X-Content-Type-Options', 'nosniff'); + this.set('Content-Type', 'text/javascript'); + + // restrict callback charset + callback = callback.replace(/[^\[\]\w$.]/g, ''); + + if (body === undefined) { + // empty argument + body = '' + } else if (typeof body === 'string') { + // replace chars not allowed in JavaScript that are in JSON + body = body + .replace(/\u2028/g, '\\u2028') + .replace(/\u2029/g, '\\u2029') + } + + // the /**/ is a specific security mitigation for "Rosetta Flash JSONP abuse" + // the typeof check is just to reduce client error noise + body = '/**/ typeof ' + callback + ' === \'function\' && ' + callback + '(' + body + ');'; + } + + return this.send(body); +}; + +/** + * Send given HTTP status code. + * + * Sets the response status to `statusCode` and the body of the + * response to the standard description from node's http.STATUS_CODES + * or the statusCode number if no description. + * + * Examples: + * + * res.sendStatus(200); + * + * @param {number} statusCode + * @public + */ + +res.sendStatus = function sendStatus(statusCode) { + var body = statuses.message[statusCode] || String(statusCode) + + this.status(statusCode); + this.type('txt'); + + return this.send(body); +}; + +/** + * Transfer the file at the given `path`. + * + * Automatically sets the _Content-Type_ response header field. + * The callback `callback(err)` is invoked when the transfer is complete + * or when an error occurs. Be sure to check `res.headersSent` + * if you wish to attempt responding, as the header and some data + * may have already been transferred. + * + * Options: + * + * - `maxAge` defaulting to 0 (can be string converted by `ms`) + * - `root` root directory for relative filenames + * - `headers` object of headers to serve with file + * - `dotfiles` serve dotfiles, defaulting to false; can be `"allow"` to send them + * + * Other options are passed along to `send`. + * + * Examples: + * + * The following example illustrates how `res.sendFile()` may + * be used as an alternative for the `static()` middleware for + * dynamic situations. The code backing `res.sendFile()` is actually + * the same code, so HTTP cache support etc is identical. + * + * app.get('/user/:uid/photos/:file', function(req, res){ + * var uid = req.params.uid + * , file = req.params.file; + * + * req.user.mayViewFilesFrom(uid, function(yes){ + * if (yes) { + * res.sendFile('/uploads/' + uid + '/' + file); + * } else { + * res.send(403, 'Sorry! you cant see that.'); + * } + * }); + * }); + * + * @public + */ + +res.sendFile = function sendFile(path, options, callback) { + var done = callback; + var req = this.req; + var res = this; + var next = req.next; + var opts = options || {}; + + if (!path) { + throw new TypeError('path argument is required to res.sendFile'); + } + + if (typeof path !== 'string') { + throw new TypeError('path must be a string to res.sendFile') + } + + // support function as second arg + if (typeof options === 'function') { + done = options; + opts = {}; + } + + if (!opts.root && !pathIsAbsolute(path)) { + throw new TypeError('path must be absolute or specify root to res.sendFile'); + } + + // create file stream + var pathname = encodeURI(path); + + // wire application etag option to send + opts.etag = this.app.enabled('etag'); + var file = send(req, pathname, opts); + + // transfer + sendfile(res, file, opts, function (err) { + if (done) return done(err); + if (err && err.code === 'EISDIR') return next(); + + // next() all but write errors + if (err && err.code !== 'ECONNABORTED' && err.syscall !== 'write') { + next(err); + } + }); +}; + +/** + * Transfer the file at the given `path` as an attachment. + * + * Optionally providing an alternate attachment `filename`, + * and optional callback `callback(err)`. The callback is invoked + * when the data transfer is complete, or when an error has + * occurred. Be sure to check `res.headersSent` if you plan to respond. + * + * Optionally providing an `options` object to use with `res.sendFile()`. + * This function will set the `Content-Disposition` header, overriding + * any `Content-Disposition` header passed as header options in order + * to set the attachment and filename. + * + * This method uses `res.sendFile()`. + * + * @public + */ + +res.download = function download (path, filename, options, callback) { + var done = callback; + var name = filename; + var opts = options || null + + // support function as second or third arg + if (typeof filename === 'function') { + done = filename; + name = null; + opts = null + } else if (typeof options === 'function') { + done = options + opts = null + } + + // support optional filename, where options may be in it's place + if (typeof filename === 'object' && + (typeof options === 'function' || options === undefined)) { + name = null + opts = filename + } + + // set Content-Disposition when file is sent + var headers = { + 'Content-Disposition': contentDisposition(name || path) + }; + + // merge user-provided headers + if (opts && opts.headers) { + var keys = Object.keys(opts.headers) + for (var i = 0; i < keys.length; i++) { + var key = keys[i] + if (key.toLowerCase() !== 'content-disposition') { + headers[key] = opts.headers[key] + } + } + } + + // merge user-provided options + opts = Object.create(opts) + opts.headers = headers + + // Resolve the full path for sendFile + var fullPath = !opts.root + ? resolve(path) + : path + + // send file + return this.sendFile(fullPath, opts, done) +}; + +/** + * Set _Content-Type_ response header with `type` through `mime.contentType()` + * when it does not contain "/", or set the Content-Type to `type` otherwise. + * When no mapping is found though `mime.contentType()`, the type is set to + * "application/octet-stream". + * + * Examples: + * + * res.type('.html'); + * res.type('html'); + * res.type('json'); + * res.type('application/json'); + * res.type('png'); + * + * @param {String} type + * @return {ServerResponse} for chaining + * @public + */ + +res.contentType = +res.type = function contentType(type) { + var ct = type.indexOf('/') === -1 + ? (mime.contentType(type) || 'application/octet-stream') + : type; + + return this.set('Content-Type', ct); +}; + +/** + * Respond to the Acceptable formats using an `obj` + * of mime-type callbacks. + * + * This method uses `req.accepted`, an array of + * acceptable types ordered by their quality values. + * When "Accept" is not present the _first_ callback + * is invoked, otherwise the first match is used. When + * no match is performed the server responds with + * 406 "Not Acceptable". + * + * Content-Type is set for you, however if you choose + * you may alter this within the callback using `res.type()` + * or `res.set('Content-Type', ...)`. + * + * res.format({ + * 'text/plain': function(){ + * res.send('hey'); + * }, + * + * 'text/html': function(){ + * res.send('

hey

'); + * }, + * + * 'application/json': function () { + * res.send({ message: 'hey' }); + * } + * }); + * + * In addition to canonicalized MIME types you may + * also use extnames mapped to these types: + * + * res.format({ + * text: function(){ + * res.send('hey'); + * }, + * + * html: function(){ + * res.send('

hey

'); + * }, + * + * json: function(){ + * res.send({ message: 'hey' }); + * } + * }); + * + * By default Express passes an `Error` + * with a `.status` of 406 to `next(err)` + * if a match is not made. If you provide + * a `.default` callback it will be invoked + * instead. + * + * @param {Object} obj + * @return {ServerResponse} for chaining + * @public + */ + +res.format = function(obj){ + var req = this.req; + var next = req.next; + + var keys = Object.keys(obj) + .filter(function (v) { return v !== 'default' }) + + var key = keys.length > 0 + ? req.accepts(keys) + : false; + + this.vary("Accept"); + + if (key) { + this.set('Content-Type', normalizeType(key).value); + obj[key](req, this, next); + } else if (obj.default) { + obj.default(req, this, next) + } else { + next(createError(406, { + types: normalizeTypes(keys).map(function (o) { return o.value }) + })) + } + + return this; +}; + +/** + * Set _Content-Disposition_ header to _attachment_ with optional `filename`. + * + * @param {String} filename + * @return {ServerResponse} + * @public + */ + +res.attachment = function attachment(filename) { + if (filename) { + this.type(extname(filename)); + } + + this.set('Content-Disposition', contentDisposition(filename)); + + return this; +}; + +/** + * Append additional header `field` with value `val`. + * + * Example: + * + * res.append('Link', ['', '']); + * res.append('Set-Cookie', 'foo=bar; Path=/; HttpOnly'); + * res.append('Warning', '199 Miscellaneous warning'); + * + * @param {String} field + * @param {String|Array} val + * @return {ServerResponse} for chaining + * @public + */ + +res.append = function append(field, val) { + var prev = this.get(field); + var value = val; + + if (prev) { + // concat the new and prev vals + value = Array.isArray(prev) ? prev.concat(val) + : Array.isArray(val) ? [prev].concat(val) + : [prev, val] + } + + return this.set(field, value); +}; + +/** + * Set header `field` to `val`, or pass + * an object of header fields. + * + * Examples: + * + * res.set('Foo', ['bar', 'baz']); + * res.set('Accept', 'application/json'); + * res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' }); + * + * Aliased as `res.header()`. + * + * When the set header is "Content-Type", the type is expanded to include + * the charset if not present using `mime.contentType()`. + * + * @param {String|Object} field + * @param {String|Array} val + * @return {ServerResponse} for chaining + * @public + */ + +res.set = +res.header = function header(field, val) { + if (arguments.length === 2) { + var value = Array.isArray(val) + ? val.map(String) + : String(val); + + // add charset to content-type + if (field.toLowerCase() === 'content-type') { + if (Array.isArray(value)) { + throw new TypeError('Content-Type cannot be set to an Array'); + } + value = mime.contentType(value) + } + + this.setHeader(field, value); + } else { + for (var key in field) { + this.set(key, field[key]); + } + } + return this; +}; + +/** + * Get value for header `field`. + * + * @param {String} field + * @return {String} + * @public + */ + +res.get = function(field){ + return this.getHeader(field); +}; + +/** + * Clear cookie `name`. + * + * @param {String} name + * @param {Object} [options] + * @return {ServerResponse} for chaining + * @public + */ + +res.clearCookie = function clearCookie(name, options) { + // Force cookie expiration by setting expires to the past + const opts = { path: '/', ...options, expires: new Date(1)}; + // ensure maxAge is not passed + delete opts.maxAge + + return this.cookie(name, '', opts); +}; + +/** + * Set cookie `name` to `value`, with the given `options`. + * + * Options: + * + * - `maxAge` max-age in milliseconds, converted to `expires` + * - `signed` sign the cookie + * - `path` defaults to "/" + * + * Examples: + * + * // "Remember Me" for 15 minutes + * res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true }); + * + * // same as above + * res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true }) + * + * @param {String} name + * @param {String|Object} value + * @param {Object} [options] + * @return {ServerResponse} for chaining + * @public + */ + +res.cookie = function (name, value, options) { + var opts = { ...options }; + var secret = this.req.secret; + var signed = opts.signed; + + if (signed && !secret) { + throw new Error('cookieParser("secret") required for signed cookies'); + } + + var val = typeof value === 'object' + ? 'j:' + JSON.stringify(value) + : String(value); + + if (signed) { + val = 's:' + sign(val, secret); + } + + if (opts.maxAge != null) { + var maxAge = opts.maxAge - 0 + + if (!isNaN(maxAge)) { + opts.expires = new Date(Date.now() + maxAge) + opts.maxAge = Math.floor(maxAge / 1000) + } + } + + if (opts.path == null) { + opts.path = '/'; + } + + this.append('Set-Cookie', cookie.serialize(name, String(val), opts)); + + return this; +}; + +/** + * Set the location header to `url`. + * + * The given `url` can also be "back", which redirects + * to the _Referrer_ or _Referer_ headers or "/". + * + * Examples: + * + * res.location('/foo/bar').; + * res.location('http://example.com'); + * res.location('../login'); + * + * @param {String} url + * @return {ServerResponse} for chaining + * @public + */ + +res.location = function location(url) { + return this.set('Location', encodeUrl(url)); +}; + +/** + * Redirect to the given `url` with optional response `status` + * defaulting to 302. + * + * Examples: + * + * res.redirect('/foo/bar'); + * res.redirect('http://example.com'); + * res.redirect(301, 'http://example.com'); + * res.redirect('../login'); // /blog/post/1 -> /blog/login + * + * @public + */ + +res.redirect = function redirect(url) { + var address = url; + var body; + var status = 302; + + // allow status / url + if (arguments.length === 2) { + status = arguments[0] + address = arguments[1] + } + + if (!address) { + deprecate('Provide a url argument'); + } + + if (typeof address !== 'string') { + deprecate('Url must be a string'); + } + + if (typeof status !== 'number') { + deprecate('Status must be a number'); + } + + // Set location header + address = this.location(address).get('Location'); + + // Support text/{plain,html} by default + this.format({ + text: function(){ + body = statuses.message[status] + '. Redirecting to ' + address + }, + + html: function(){ + var u = escapeHtml(address); + body = '

' + statuses.message[status] + '. Redirecting to ' + u + '

' + }, + + default: function(){ + body = ''; + } + }); + + // Respond + this.status(status); + this.set('Content-Length', Buffer.byteLength(body)); + + if (this.req.method === 'HEAD') { + this.end(); + } else { + this.end(body); + } +}; + +/** + * Add `field` to Vary. If already present in the Vary set, then + * this call is simply ignored. + * + * @param {Array|String} field + * @return {ServerResponse} for chaining + * @public + */ + +res.vary = function(field){ + vary(this, field); + + return this; +}; + +/** + * Render `view` with the given `options` and optional callback `fn`. + * When a callback function is given a response will _not_ be made + * automatically, otherwise a response of _200_ and _text/html_ is given. + * + * Options: + * + * - `cache` boolean hinting to the engine it should cache + * - `filename` filename of the view being rendered + * + * @public + */ + +res.render = function render(view, options, callback) { + var app = this.req.app; + var done = callback; + var opts = options || {}; + var req = this.req; + var self = this; + + // support callback function as second arg + if (typeof options === 'function') { + done = options; + opts = {}; + } + + // merge res.locals + opts._locals = self.locals; + + // default callback to respond + done = done || function (err, str) { + if (err) return req.next(err); + self.send(str); + }; + + // render + app.render(view, opts, done); +}; + +// pipe the send file stream +function sendfile(res, file, options, callback) { + var done = false; + var streaming; + + // request aborted + function onaborted() { + if (done) return; + done = true; + + var err = new Error('Request aborted'); + err.code = 'ECONNABORTED'; + callback(err); + } + + // directory + function ondirectory() { + if (done) return; + done = true; + + var err = new Error('EISDIR, read'); + err.code = 'EISDIR'; + callback(err); + } + + // errors + function onerror(err) { + if (done) return; + done = true; + callback(err); + } + + // ended + function onend() { + if (done) return; + done = true; + callback(); + } + + // file + function onfile() { + streaming = false; + } + + // finished + function onfinish(err) { + if (err && err.code === 'ECONNRESET') return onaborted(); + if (err) return onerror(err); + if (done) return; + + setImmediate(function () { + if (streaming !== false && !done) { + onaborted(); + return; + } + + if (done) return; + done = true; + callback(); + }); + } + + // streaming + function onstream() { + streaming = true; + } + + file.on('directory', ondirectory); + file.on('end', onend); + file.on('error', onerror); + file.on('file', onfile); + file.on('stream', onstream); + onFinished(res, onfinish); + + if (options.headers) { + // set headers on successful transfer + file.on('headers', function headers(res) { + var obj = options.headers; + var keys = Object.keys(obj); + + for (var i = 0; i < keys.length; i++) { + var k = keys[i]; + res.setHeader(k, obj[k]); + } + }); + } + + // pipe + file.pipe(res); +} + +/** + * Stringify JSON, like JSON.stringify, but v8 optimized, with the + * ability to escape characters that can trigger HTML sniffing. + * + * @param {*} value + * @param {function} replacer + * @param {number} spaces + * @param {boolean} escape + * @returns {string} + * @private + */ + +function stringify (value, replacer, spaces, escape) { + // v8 checks arguments.length for optimizing simple call + // https://bugs.chromium.org/p/v8/issues/detail?id=4730 + var json = replacer || spaces + ? JSON.stringify(value, replacer, spaces) + : JSON.stringify(value); + + if (escape && typeof json === 'string') { + json = json.replace(/[<>&]/g, function (c) { + switch (c.charCodeAt(0)) { + case 0x3c: + return '\\u003c' + case 0x3e: + return '\\u003e' + case 0x26: + return '\\u0026' + /* istanbul ignore next: unreachable default */ + default: + return c + } + }) + } + + return json +} diff --git a/tools/ui/node_modules/express/lib/utils.js b/tools/ui/node_modules/express/lib/utils.js new file mode 100644 index 0000000000000000000000000000000000000000..4f21e7ef1e3d2ed8da18a9671f983b012e45198b --- /dev/null +++ b/tools/ui/node_modules/express/lib/utils.js @@ -0,0 +1,271 @@ +/*! + * express + * Copyright(c) 2009-2013 TJ Holowaychuk + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict'; + +/** + * Module dependencies. + * @api private + */ + +var { METHODS } = require('node:http'); +var contentType = require('content-type'); +var etag = require('etag'); +var mime = require('mime-types') +var proxyaddr = require('proxy-addr'); +var qs = require('qs'); +var querystring = require('node:querystring'); +const { Buffer } = require('node:buffer'); + + +/** + * A list of lowercased HTTP methods that are supported by Node.js. + * @api private + */ +exports.methods = METHODS.map((method) => method.toLowerCase()); + +/** + * Return strong ETag for `body`. + * + * @param {String|Buffer} body + * @param {String} [encoding] + * @return {String} + * @api private + */ + +exports.etag = createETagGenerator({ weak: false }) + +/** + * Return weak ETag for `body`. + * + * @param {String|Buffer} body + * @param {String} [encoding] + * @return {String} + * @api private + */ + +exports.wetag = createETagGenerator({ weak: true }) + +/** + * Normalize the given `type`, for example "html" becomes "text/html". + * + * @param {String} type + * @return {Object} + * @api private + */ + +exports.normalizeType = function(type){ + return ~type.indexOf('/') + ? acceptParams(type) + : { value: (mime.lookup(type) || 'application/octet-stream'), params: {} } +}; + +/** + * Normalize `types`, for example "html" becomes "text/html". + * + * @param {Array} types + * @return {Array} + * @api private + */ + +exports.normalizeTypes = function(types) { + return types.map(exports.normalizeType); +}; + + +/** + * Parse accept params `str` returning an + * object with `.value`, `.quality` and `.params`. + * + * @param {String} str + * @return {Object} + * @api private + */ + +function acceptParams (str) { + var length = str.length; + var colonIndex = str.indexOf(';'); + var index = colonIndex === -1 ? length : colonIndex; + var ret = { value: str.slice(0, index).trim(), quality: 1, params: {} }; + + while (index < length) { + var splitIndex = str.indexOf('=', index); + if (splitIndex === -1) break; + + var colonIndex = str.indexOf(';', index); + var endIndex = colonIndex === -1 ? length : colonIndex; + + if (splitIndex > endIndex) { + index = str.lastIndexOf(';', splitIndex - 1) + 1; + continue; + } + + var key = str.slice(index, splitIndex).trim(); + var value = str.slice(splitIndex + 1, endIndex).trim(); + + if (key === 'q') { + ret.quality = parseFloat(value); + } else { + ret.params[key] = value; + } + + index = endIndex + 1; + } + + return ret; +} + +/** + * Compile "etag" value to function. + * + * @param {Boolean|String|Function} val + * @return {Function} + * @api private + */ + +exports.compileETag = function(val) { + var fn; + + if (typeof val === 'function') { + return val; + } + + switch (val) { + case true: + case 'weak': + fn = exports.wetag; + break; + case false: + break; + case 'strong': + fn = exports.etag; + break; + default: + throw new TypeError('unknown value for etag function: ' + val); + } + + return fn; +} + +/** + * Compile "query parser" value to function. + * + * @param {String|Function} val + * @return {Function} + * @api private + */ + +exports.compileQueryParser = function compileQueryParser(val) { + var fn; + + if (typeof val === 'function') { + return val; + } + + switch (val) { + case true: + case 'simple': + fn = querystring.parse; + break; + case false: + break; + case 'extended': + fn = parseExtendedQueryString; + break; + default: + throw new TypeError('unknown value for query parser function: ' + val); + } + + return fn; +} + +/** + * Compile "proxy trust" value to function. + * + * @param {Boolean|String|Number|Array|Function} val + * @return {Function} + * @api private + */ + +exports.compileTrust = function(val) { + if (typeof val === 'function') return val; + + if (val === true) { + // Support plain true/false + return function(){ return true }; + } + + if (typeof val === 'number') { + // Support trusting hop count + return function(a, i){ return i < val }; + } + + if (typeof val === 'string') { + // Support comma-separated values + val = val.split(',') + .map(function (v) { return v.trim() }) + } + + return proxyaddr.compile(val || []); +} + +/** + * Set the charset in a given Content-Type string. + * + * @param {String} type + * @param {String} charset + * @return {String} + * @api private + */ + +exports.setCharset = function setCharset(type, charset) { + if (!type || !charset) { + return type; + } + + // parse type + var parsed = contentType.parse(type); + + // set charset + parsed.parameters.charset = charset; + + // format type + return contentType.format(parsed); +}; + +/** + * Create an ETag generator function, generating ETags with + * the given options. + * + * @param {object} options + * @return {function} + * @private + */ + +function createETagGenerator (options) { + return function generateETag (body, encoding) { + var buf = !Buffer.isBuffer(body) + ? Buffer.from(body, encoding) + : body + + return etag(buf, options) + } +} + +/** + * Parse an extended query string with qs. + * + * @param {String} str + * @return {Object} + * @private + */ + +function parseExtendedQueryString(str) { + return qs.parse(str, { + allowPrototypes: true + }); +} diff --git a/tools/ui/node_modules/express/lib/view.js b/tools/ui/node_modules/express/lib/view.js new file mode 100644 index 0000000000000000000000000000000000000000..d66b4a2d89cda638ca1dcbba3da090e631175fc1 --- /dev/null +++ b/tools/ui/node_modules/express/lib/view.js @@ -0,0 +1,205 @@ +/*! + * express + * Copyright(c) 2009-2013 TJ Holowaychuk + * Copyright(c) 2013 Roman Shtylman + * Copyright(c) 2014-2015 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict'; + +/** + * Module dependencies. + * @private + */ + +var debug = require('debug')('express:view'); +var path = require('node:path'); +var fs = require('node:fs'); + +/** + * Module variables. + * @private + */ + +var dirname = path.dirname; +var basename = path.basename; +var extname = path.extname; +var join = path.join; +var resolve = path.resolve; + +/** + * Module exports. + * @public + */ + +module.exports = View; + +/** + * Initialize a new `View` with the given `name`. + * + * Options: + * + * - `defaultEngine` the default template engine name + * - `engines` template engine require() cache + * - `root` root path for view lookup + * + * @param {string} name + * @param {object} options + * @public + */ + +function View(name, options) { + var opts = options || {}; + + this.defaultEngine = opts.defaultEngine; + this.ext = extname(name); + this.name = name; + this.root = opts.root; + + if (!this.ext && !this.defaultEngine) { + throw new Error('No default engine was specified and no extension was provided.'); + } + + var fileName = name; + + if (!this.ext) { + // get extension from default engine name + this.ext = this.defaultEngine[0] !== '.' + ? '.' + this.defaultEngine + : this.defaultEngine; + + fileName += this.ext; + } + + if (!opts.engines[this.ext]) { + // load engine + var mod = this.ext.slice(1) + debug('require "%s"', mod) + + // default engine export + var fn = require(mod).__express + + if (typeof fn !== 'function') { + throw new Error('Module "' + mod + '" does not provide a view engine.') + } + + opts.engines[this.ext] = fn + } + + // store loaded engine + this.engine = opts.engines[this.ext]; + + // lookup path + this.path = this.lookup(fileName); +} + +/** + * Lookup view by the given `name` + * + * @param {string} name + * @private + */ + +View.prototype.lookup = function lookup(name) { + var path; + var roots = [].concat(this.root); + + debug('lookup "%s"', name); + + for (var i = 0; i < roots.length && !path; i++) { + var root = roots[i]; + + // resolve the path + var loc = resolve(root, name); + var dir = dirname(loc); + var file = basename(loc); + + // resolve the file + path = this.resolve(dir, file); + } + + return path; +}; + +/** + * Render with the given options. + * + * @param {object} options + * @param {function} callback + * @private + */ + +View.prototype.render = function render(options, callback) { + var sync = true; + + debug('render "%s"', this.path); + + // render, normalizing sync callbacks + this.engine(this.path, options, function onRender() { + if (!sync) { + return callback.apply(this, arguments); + } + + // copy arguments + var args = new Array(arguments.length); + var cntx = this; + + for (var i = 0; i < arguments.length; i++) { + args[i] = arguments[i]; + } + + // force callback to be async + return process.nextTick(function renderTick() { + return callback.apply(cntx, args); + }); + }); + + sync = false; +}; + +/** + * Resolve the file within the given directory. + * + * @param {string} dir + * @param {string} file + * @private + */ + +View.prototype.resolve = function resolve(dir, file) { + var ext = this.ext; + + // . + var path = join(dir, file); + var stat = tryStat(path); + + if (stat && stat.isFile()) { + return path; + } + + // /index. + path = join(dir, basename(file, ext), 'index' + ext); + stat = tryStat(path); + + if (stat && stat.isFile()) { + return path; + } +}; + +/** + * Return a stat, maybe. + * + * @param {string} path + * @return {fs.Stats} + * @private + */ + +function tryStat(path) { + debug('stat "%s"', path); + + try { + return fs.statSync(path); + } catch (e) { + return undefined; + } +} diff --git a/tools/ui/node_modules/express/package.json b/tools/ui/node_modules/express/package.json new file mode 100644 index 0000000000000000000000000000000000000000..8f358830d97f07e22bd7a38982080e9fbc4fc6a7 --- /dev/null +++ b/tools/ui/node_modules/express/package.json @@ -0,0 +1,99 @@ +{ + "name": "express", + "description": "Fast, unopinionated, minimalist web framework", + "version": "5.2.1", + "author": "TJ Holowaychuk ", + "contributors": [ + "Aaron Heckmann ", + "Ciaran Jessup ", + "Douglas Christopher Wilson ", + "Guillermo Rauch ", + "Jonathan Ong ", + "Roman Shtylman ", + "Young Jae Sim " + ], + "license": "MIT", + "repository": "expressjs/express", + "homepage": "https://expressjs.com/", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + }, + "keywords": [ + "express", + "framework", + "sinatra", + "web", + "http", + "rest", + "restful", + "router", + "app", + "api" + ], + "dependencies": { + "accepts": "^2.0.0", + "body-parser": "^2.2.1", + "content-disposition": "^1.0.0", + "content-type": "^1.0.5", + "cookie": "^0.7.1", + "cookie-signature": "^1.2.1", + "debug": "^4.4.0", + "depd": "^2.0.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "etag": "^1.8.1", + "finalhandler": "^2.1.0", + "fresh": "^2.0.0", + "http-errors": "^2.0.0", + "merge-descriptors": "^2.0.0", + "mime-types": "^3.0.0", + "on-finished": "^2.4.1", + "once": "^1.4.0", + "parseurl": "^1.3.3", + "proxy-addr": "^2.0.7", + "qs": "^6.14.0", + "range-parser": "^1.2.1", + "router": "^2.2.0", + "send": "^1.1.0", + "serve-static": "^2.2.0", + "statuses": "^2.0.1", + "type-is": "^2.0.1", + "vary": "^1.1.2" + }, + "devDependencies": { + "after": "0.8.2", + "connect-redis": "^8.0.1", + "cookie-parser": "1.4.7", + "cookie-session": "2.1.1", + "ejs": "^3.1.10", + "eslint": "8.47.0", + "express-session": "^1.18.1", + "hbs": "4.2.0", + "marked": "^15.0.3", + "method-override": "3.0.0", + "mocha": "^10.7.3", + "morgan": "1.10.1", + "nyc": "^17.1.0", + "pbkdf2-password": "1.2.1", + "supertest": "^6.3.0", + "vhost": "~3.0.2" + }, + "engines": { + "node": ">= 18" + }, + "files": [ + "LICENSE", + "Readme.md", + "index.js", + "lib/" + ], + "scripts": { + "lint": "eslint .", + "lint:fix": "eslint . --fix", + "test": "mocha --require test/support/env --reporter spec --check-leaks test/ test/acceptance/", + "test-ci": "nyc --exclude examples --exclude test --exclude benchmarks --reporter=lcovonly --reporter=text npm test", + "test-cov": "nyc --exclude examples --exclude test --exclude benchmarks --reporter=html --reporter=text npm test", + "test-tap": "mocha --require test/support/env --reporter tap --check-leaks test/ test/acceptance/" + } +} diff --git a/tools/ui/node_modules/extend/.editorconfig b/tools/ui/node_modules/extend/.editorconfig new file mode 100644 index 0000000000000000000000000000000000000000..bc228f8269443bf772b437890dde7756a3e8a894 --- /dev/null +++ b/tools/ui/node_modules/extend/.editorconfig @@ -0,0 +1,20 @@ +root = true + +[*] +indent_style = tab +indent_size = 4 +end_of_line = lf +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true +max_line_length = 150 + +[CHANGELOG.md] +indent_style = space +indent_size = 2 + +[*.json] +max_line_length = off + +[Makefile] +max_line_length = off diff --git a/tools/ui/node_modules/extend/.eslintrc b/tools/ui/node_modules/extend/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..a34cf2831b7c383001ea86570f8b63686c285c60 --- /dev/null +++ b/tools/ui/node_modules/extend/.eslintrc @@ -0,0 +1,17 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "complexity": [2, 20], + "eqeqeq": [2, "allow-null"], + "func-name-matching": [1], + "max-depth": [1, 4], + "max-statements": [2, 26], + "no-extra-parens": [1], + "no-magic-numbers": [0], + "no-restricted-syntax": [2, "BreakStatement", "ContinueStatement", "DebuggerStatement", "LabeledStatement", "WithStatement"], + "sort-keys": [0], + } +} diff --git a/tools/ui/node_modules/extend/.jscs.json b/tools/ui/node_modules/extend/.jscs.json new file mode 100644 index 0000000000000000000000000000000000000000..3cce01d7832943debaf60e58033d8a110daacbca --- /dev/null +++ b/tools/ui/node_modules/extend/.jscs.json @@ -0,0 +1,175 @@ +{ + "es3": true, + + "additionalRules": [], + + "requireSemicolons": true, + + "disallowMultipleSpaces": true, + + "disallowIdentifierNames": [], + + "requireCurlyBraces": { + "allExcept": [], + "keywords": ["if", "else", "for", "while", "do", "try", "catch"] + }, + + "requireSpaceAfterKeywords": ["if", "else", "for", "while", "do", "switch", "return", "try", "catch", "function"], + + "disallowSpaceAfterKeywords": [], + + "disallowSpaceBeforeComma": true, + "disallowSpaceAfterComma": false, + "disallowSpaceBeforeSemicolon": true, + + "disallowNodeTypes": [ + "DebuggerStatement", + "LabeledStatement", + "SwitchCase", + "SwitchStatement", + "WithStatement" + ], + + "requireObjectKeysOnNewLine": { "allExcept": ["sameLine"] }, + + "requireSpacesInAnonymousFunctionExpression": { "beforeOpeningRoundBrace": true, "beforeOpeningCurlyBrace": true }, + "requireSpacesInNamedFunctionExpression": { "beforeOpeningCurlyBrace": true }, + "disallowSpacesInNamedFunctionExpression": { "beforeOpeningRoundBrace": true }, + "requireSpacesInFunctionDeclaration": { "beforeOpeningCurlyBrace": true }, + "disallowSpacesInFunctionDeclaration": { "beforeOpeningRoundBrace": true }, + + "requireSpaceBetweenArguments": true, + + "disallowSpacesInsideParentheses": true, + + "disallowSpacesInsideArrayBrackets": true, + + "disallowQuotedKeysInObjects": { "allExcept": ["reserved"] }, + + "disallowSpaceAfterObjectKeys": true, + + "requireCommaBeforeLineBreak": true, + + "disallowSpaceAfterPrefixUnaryOperators": ["++", "--", "+", "-", "~", "!"], + "requireSpaceAfterPrefixUnaryOperators": [], + + "disallowSpaceBeforePostfixUnaryOperators": ["++", "--"], + "requireSpaceBeforePostfixUnaryOperators": [], + + "disallowSpaceBeforeBinaryOperators": [], + "requireSpaceBeforeBinaryOperators": ["+", "-", "/", "*", "=", "==", "===", "!=", "!=="], + + "requireSpaceAfterBinaryOperators": ["+", "-", "/", "*", "=", "==", "===", "!=", "!=="], + "disallowSpaceAfterBinaryOperators": [], + + "disallowImplicitTypeConversion": ["binary", "string"], + + "disallowKeywords": ["with", "eval"], + + "requireKeywordsOnNewLine": [], + "disallowKeywordsOnNewLine": ["else"], + + "requireLineFeedAtFileEnd": true, + + "disallowTrailingWhitespace": true, + + "disallowTrailingComma": true, + + "excludeFiles": ["node_modules/**", "vendor/**"], + + "disallowMultipleLineStrings": true, + + "requireDotNotation": { "allExcept": ["keywords"] }, + + "requireParenthesesAroundIIFE": true, + + "validateLineBreaks": "LF", + + "validateQuoteMarks": { + "escape": true, + "mark": "'" + }, + + "disallowOperatorBeforeLineBreak": [], + + "requireSpaceBeforeKeywords": [ + "do", + "for", + "if", + "else", + "switch", + "case", + "try", + "catch", + "finally", + "while", + "with", + "return" + ], + + "validateAlignedFunctionParameters": { + "lineBreakAfterOpeningBraces": true, + "lineBreakBeforeClosingBraces": true + }, + + "requirePaddingNewLinesBeforeExport": true, + + "validateNewlineAfterArrayElements": { + "maximum": 6 + }, + + "requirePaddingNewLinesAfterUseStrict": true, + + "disallowArrowFunctions": true, + + "disallowMultiLineTernary": true, + + "validateOrderInObjectKeys": false, + + "disallowIdenticalDestructuringNames": true, + + "disallowNestedTernaries": { "maxLevel": 1 }, + + "requireSpaceAfterComma": { "allExcept": ["trailing"] }, + "requireAlignedMultilineParams": false, + + "requireSpacesInGenerator": { + "afterStar": true + }, + + "disallowSpacesInGenerator": { + "beforeStar": true + }, + + "disallowVar": false, + + "requireArrayDestructuring": false, + + "requireEnhancedObjectLiterals": false, + + "requireObjectDestructuring": false, + + "requireEarlyReturn": false, + + "requireCapitalizedConstructorsNew": { + "allExcept": ["Function", "String", "Object", "Symbol", "Number", "Date", "RegExp", "Error", "Boolean", "Array"] + }, + + "requireImportAlphabetized": false, + + "requireSpaceBeforeObjectValues": true, + "requireSpaceBeforeDestructuredValues": true, + + "disallowSpacesInsideTemplateStringPlaceholders": true, + + "disallowArrayDestructuringReturn": false, + + "requireNewlineBeforeSingleStatementsInIf": false, + + "disallowUnusedVariables": true, + + "requireSpacesInsideImportedObjectBraces": true, + + "requireUseStrict": true +} + diff --git a/tools/ui/node_modules/extend/.travis.yml b/tools/ui/node_modules/extend/.travis.yml new file mode 100644 index 0000000000000000000000000000000000000000..5ccdfc4948155fbc286e92c049aa2a4468858762 --- /dev/null +++ b/tools/ui/node_modules/extend/.travis.yml @@ -0,0 +1,230 @@ +language: node_js +os: + - linux +node_js: + - "10.7" + - "9.11" + - "8.11" + - "7.10" + - "6.14" + - "5.12" + - "4.9" + - "iojs-v3.3" + - "iojs-v2.5" + - "iojs-v1.8" + - "0.12" + - "0.10" + - "0.8" +before_install: + - 'case "${TRAVIS_NODE_VERSION}" in 0.*) export NPM_CONFIG_STRICT_SSL=false ;; esac' + - 'nvm install-latest-npm' +install: + - 'if [ "${TRAVIS_NODE_VERSION}" = "0.6" ] || [ "${TRAVIS_NODE_VERSION}" = "0.9" ]; then nvm install --latest-npm 0.8 && npm install && nvm use "${TRAVIS_NODE_VERSION}"; else npm install; fi;' +script: + - 'if [ -n "${PRETEST-}" ]; then npm run pretest ; fi' + - 'if [ -n "${POSTTEST-}" ]; then npm run posttest ; fi' + - 'if [ -n "${COVERAGE-}" ]; then npm run coverage ; fi' + - 'if [ -n "${TEST-}" ]; then npm run tests-only ; fi' +sudo: false +env: + - TEST=true +matrix: + fast_finish: true + include: + - node_js: "lts/*" + env: PRETEST=true + - node_js: "lts/*" + env: POSTTEST=true + - node_js: "4" + env: COVERAGE=true + - node_js: "10.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "10.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.10" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "9.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.10" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "8.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "7.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.13" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.12" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.11" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.10" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "6.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.11" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.10" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "5.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.8" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "4.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v3.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v3.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v3.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v2.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v2.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v2.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v2.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v2.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.7" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.5" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.4" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.3" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.2" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.1" + env: TEST=true ALLOW_FAILURE=true + - node_js: "iojs-v1.0" + env: TEST=true ALLOW_FAILURE=true + - node_js: "0.11" + env: TEST=true ALLOW_FAILURE=true + - node_js: "0.9" + env: TEST=true ALLOW_FAILURE=true + - node_js: "0.6" + env: TEST=true ALLOW_FAILURE=true + - node_js: "0.4" + env: TEST=true ALLOW_FAILURE=true + allow_failures: + - os: osx + - env: TEST=true ALLOW_FAILURE=true diff --git a/tools/ui/node_modules/extend/CHANGELOG.md b/tools/ui/node_modules/extend/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..2cf7de6fb3ae5dc0c67aeb92f2d6969adc36630d --- /dev/null +++ b/tools/ui/node_modules/extend/CHANGELOG.md @@ -0,0 +1,83 @@ +3.0.2 / 2018-07-19 +================== + * [Fix] Prevent merging `__proto__` property (#48) + * [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` + * [Tests] up to `node` `v10.7`, `v9.11`, `v8.11`, `v7.10`, `v6.14`, `v4.9`; use `nvm install-latest-npm` + +3.0.1 / 2017-04-27 +================== + * [Fix] deep extending should work with a non-object (#46) + * [Dev Deps] update `tape`, `eslint`, `@ljharb/eslint-config` + * [Tests] up to `node` `v7.9`, `v6.10`, `v4.8`; improve matrix + * [Docs] Switch from vb.teelaun.ch to versionbadg.es for the npm version badge SVG. + * [Docs] Add example to readme (#34) + +3.0.0 / 2015-07-01 +================== + * [Possible breaking change] Use global "strict" directive (#32) + * [Tests] `int` is an ES3 reserved word + * [Tests] Test up to `io.js` `v2.3` + * [Tests] Add `npm run eslint` + * [Dev Deps] Update `covert`, `jscs` + +2.0.1 / 2015-04-25 +================== + * Use an inline `isArray` check, for ES3 browsers. (#27) + * Some old browsers fail when an identifier is `toString` + * Test latest `node` and `io.js` versions on `travis-ci`; speed up builds + * Add license info to package.json (#25) + * Update `tape`, `jscs` + * Adding a CHANGELOG + +2.0.0 / 2014-10-01 +================== + * Increase code coverage to 100%; run code coverage as part of tests + * Add `npm run lint`; Run linter as part of tests + * Remove nodeType and setInterval checks in isPlainObject + * Updating `tape`, `jscs`, `covert` + * General style and README cleanup + +1.3.0 / 2014-06-20 +================== + * Add component.json for browser support (#18) + * Use SVG for badges in README (#16) + * Updating `tape`, `covert` + * Updating travis-ci to work with multiple node versions + * Fix `deep === false` bug (returning target as {}) (#14) + * Fixing constructor checks in isPlainObject + * Adding additional test coverage + * Adding `npm run coverage` + * Add LICENSE (#13) + * Adding a warning about `false`, per #11 + * General style and whitespace cleanup + +1.2.1 / 2013-09-14 +================== + * Fixing hasOwnProperty bugs that would only have shown up in specific browsers. Fixes #8 + * Updating `tape` + +1.2.0 / 2013-09-02 +================== + * Updating the README: add badges + * Adding a missing variable reference. + * Using `tape` instead of `buster` for tests; add more tests (#7) + * Adding node 0.10 to Travis CI (#6) + * Enabling "npm test" and cleaning up package.json (#5) + * Add Travis CI. + +1.1.3 / 2012-12-06 +================== + * Added unit tests. + * Ensure extend function is named. (Looks nicer in a stack trace.) + * README cleanup. + +1.1.1 / 2012-11-07 +================== + * README cleanup. + * Added installation instructions. + * Added a missing semicolon + +1.0.0 / 2012-04-08 +================== + * Initial commit + diff --git a/tools/ui/node_modules/extend/LICENSE b/tools/ui/node_modules/extend/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..e16d6a56ca64e235d9065c37f4566a0fe0be28d4 --- /dev/null +++ b/tools/ui/node_modules/extend/LICENSE @@ -0,0 +1,23 @@ +The MIT License (MIT) + +Copyright (c) 2014 Stefan Thomas + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + diff --git a/tools/ui/node_modules/extend/README.md b/tools/ui/node_modules/extend/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5b8249aa95e5d34927c0b44988b29fcda85cb1cd --- /dev/null +++ b/tools/ui/node_modules/extend/README.md @@ -0,0 +1,81 @@ +[![Build Status][travis-svg]][travis-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] + +# extend() for Node.js [![Version Badge][npm-version-png]][npm-url] + +`node-extend` is a port of the classic extend() method from jQuery. It behaves as you expect. It is simple, tried and true. + +Notes: + +* Since Node.js >= 4, + [`Object.assign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign) + now offers the same functionality natively (but without the "deep copy" option). + See [ECMAScript 2015 (ES6) in Node.js](https://nodejs.org/en/docs/es6). +* Some native implementations of `Object.assign` in both Node.js and many + browsers (since NPM modules are for the browser too) may not be fully + spec-compliant. + Check [`object.assign`](https://www.npmjs.com/package/object.assign) module for + a compliant candidate. + +## Installation + +This package is available on [npm][npm-url] as: `extend` + +``` sh +npm install extend +``` + +## Usage + +**Syntax:** extend **(** [`deep`], `target`, `object1`, [`objectN`] **)** + +*Extend one object with one or more others, returning the modified object.* + +**Example:** + +``` js +var extend = require('extend'); +extend(targetObject, object1, object2); +``` + +Keep in mind that the target object will be modified, and will be returned from extend(). + +If a boolean true is specified as the first argument, extend performs a deep copy, recursively copying any objects it finds. Otherwise, the copy will share structure with the original object(s). +Undefined properties are not copied. However, properties inherited from the object's prototype will be copied over. +Warning: passing `false` as the first argument is not supported. + +### Arguments + +* `deep` *Boolean* (optional) +If set, the merge becomes recursive (i.e. deep copy). +* `target` *Object* +The object to extend. +* `object1` *Object* +The object that will be merged into the first. +* `objectN` *Object* (Optional) +More objects to merge into the first. + +## License + +`node-extend` is licensed under the [MIT License][mit-license-url]. + +## Acknowledgements + +All credit to the jQuery authors for perfecting this amazing utility. + +Ported to Node.js by [Stefan Thomas][github-justmoon] with contributions by [Jonathan Buchanan][github-insin] and [Jordan Harband][github-ljharb]. + +[travis-svg]: https://travis-ci.org/justmoon/node-extend.svg +[travis-url]: https://travis-ci.org/justmoon/node-extend +[npm-url]: https://npmjs.org/package/extend +[mit-license-url]: http://opensource.org/licenses/MIT +[github-justmoon]: https://github.com/justmoon +[github-insin]: https://github.com/insin +[github-ljharb]: https://github.com/ljharb +[npm-version-png]: http://versionbadg.es/justmoon/node-extend.svg +[deps-svg]: https://david-dm.org/justmoon/node-extend.svg +[deps-url]: https://david-dm.org/justmoon/node-extend +[dev-deps-svg]: https://david-dm.org/justmoon/node-extend/dev-status.svg +[dev-deps-url]: https://david-dm.org/justmoon/node-extend#info=devDependencies + diff --git a/tools/ui/node_modules/extend/component.json b/tools/ui/node_modules/extend/component.json new file mode 100644 index 0000000000000000000000000000000000000000..1500a2f37181823ef8500854e8bbe613fbc5215a --- /dev/null +++ b/tools/ui/node_modules/extend/component.json @@ -0,0 +1,32 @@ +{ + "name": "extend", + "author": "Stefan Thomas (http://www.justmoon.net)", + "version": "3.0.0", + "description": "Port of jQuery.extend for node.js and the browser.", + "scripts": [ + "index.js" + ], + "contributors": [ + { + "name": "Jordan Harband", + "url": "https://github.com/ljharb" + } + ], + "keywords": [ + "extend", + "clone", + "merge" + ], + "repository" : { + "type": "git", + "url": "https://github.com/justmoon/node-extend.git" + }, + "dependencies": { + }, + "devDependencies": { + "tape" : "~3.0.0", + "covert": "~0.4.0", + "jscs": "~1.6.2" + } +} + diff --git a/tools/ui/node_modules/extend/index.js b/tools/ui/node_modules/extend/index.js new file mode 100644 index 0000000000000000000000000000000000000000..2aa3faae68c43e0221134e0ee72a713fd7d47a5f --- /dev/null +++ b/tools/ui/node_modules/extend/index.js @@ -0,0 +1,117 @@ +'use strict'; + +var hasOwn = Object.prototype.hasOwnProperty; +var toStr = Object.prototype.toString; +var defineProperty = Object.defineProperty; +var gOPD = Object.getOwnPropertyDescriptor; + +var isArray = function isArray(arr) { + if (typeof Array.isArray === 'function') { + return Array.isArray(arr); + } + + return toStr.call(arr) === '[object Array]'; +}; + +var isPlainObject = function isPlainObject(obj) { + if (!obj || toStr.call(obj) !== '[object Object]') { + return false; + } + + var hasOwnConstructor = hasOwn.call(obj, 'constructor'); + var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); + // Not own constructor property must be Object + if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) { + return false; + } + + // Own properties are enumerated firstly, so to speed up, + // if last one is own, then all properties are own. + var key; + for (key in obj) { /**/ } + + return typeof key === 'undefined' || hasOwn.call(obj, key); +}; + +// If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target +var setProperty = function setProperty(target, options) { + if (defineProperty && options.name === '__proto__') { + defineProperty(target, options.name, { + enumerable: true, + configurable: true, + value: options.newValue, + writable: true + }); + } else { + target[options.name] = options.newValue; + } +}; + +// Return undefined instead of __proto__ if '__proto__' is not an own property +var getProperty = function getProperty(obj, name) { + if (name === '__proto__') { + if (!hasOwn.call(obj, name)) { + return void 0; + } else if (gOPD) { + // In early versions of node, obj['__proto__'] is buggy when obj has + // __proto__ as an own property. Object.getOwnPropertyDescriptor() works. + return gOPD(obj, name).value; + } + } + + return obj[name]; +}; + +module.exports = function extend() { + var options, name, src, copy, copyIsArray, clone; + var target = arguments[0]; + var i = 1; + var length = arguments.length; + var deep = false; + + // Handle a deep copy situation + if (typeof target === 'boolean') { + deep = target; + target = arguments[1] || {}; + // skip the boolean and the target + i = 2; + } + if (target == null || (typeof target !== 'object' && typeof target !== 'function')) { + target = {}; + } + + for (; i < length; ++i) { + options = arguments[i]; + // Only deal with non-null/undefined values + if (options != null) { + // Extend the base object + for (name in options) { + src = getProperty(target, name); + copy = getProperty(options, name); + + // Prevent never-ending loop + if (target !== copy) { + // Recurse if we're merging plain objects or arrays + if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { + if (copyIsArray) { + copyIsArray = false; + clone = src && isArray(src) ? src : []; + } else { + clone = src && isPlainObject(src) ? src : {}; + } + + // Never move original objects, clone them + setProperty(target, { name: name, newValue: extend(deep, clone, copy) }); + + // Don't bring in undefined values + } else if (typeof copy !== 'undefined') { + setProperty(target, { name: name, newValue: copy }); + } + } + } + } + } + + // Return the modified object + return target; +}; diff --git a/tools/ui/node_modules/extend/package.json b/tools/ui/node_modules/extend/package.json new file mode 100644 index 0000000000000000000000000000000000000000..85279f78054e5cc6d7f9899afaf9fca60b77d740 --- /dev/null +++ b/tools/ui/node_modules/extend/package.json @@ -0,0 +1,42 @@ +{ + "name": "extend", + "author": "Stefan Thomas (http://www.justmoon.net)", + "version": "3.0.2", + "description": "Port of jQuery.extend for node.js and the browser", + "main": "index", + "scripts": { + "pretest": "npm run lint", + "test": "npm run tests-only", + "posttest": "npm run coverage-quiet", + "tests-only": "node test", + "coverage": "covert test/index.js", + "coverage-quiet": "covert test/index.js --quiet", + "lint": "npm run jscs && npm run eslint", + "jscs": "jscs *.js */*.js", + "eslint": "eslint *.js */*.js" + }, + "contributors": [ + { + "name": "Jordan Harband", + "url": "https://github.com/ljharb" + } + ], + "keywords": [ + "extend", + "clone", + "merge" + ], + "repository": { + "type": "git", + "url": "https://github.com/justmoon/node-extend.git" + }, + "dependencies": {}, + "devDependencies": { + "@ljharb/eslint-config": "^12.2.1", + "covert": "^1.1.0", + "eslint": "^4.19.1", + "jscs": "^3.0.7", + "tape": "^4.9.1" + }, + "license": "MIT" +} diff --git a/tools/ui/node_modules/fast-deep-equal/LICENSE b/tools/ui/node_modules/fast-deep-equal/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..7f1543566f6abbbf75914db32651cf89919cabed --- /dev/null +++ b/tools/ui/node_modules/fast-deep-equal/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 Evgeny Poberezkin + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/fast-deep-equal/README.md b/tools/ui/node_modules/fast-deep-equal/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d3f4ffcc316f965a5989bf0365cc4716d394878c --- /dev/null +++ b/tools/ui/node_modules/fast-deep-equal/README.md @@ -0,0 +1,96 @@ +# fast-deep-equal +The fastest deep equal with ES6 Map, Set and Typed arrays support. + +[![Build Status](https://travis-ci.org/epoberezkin/fast-deep-equal.svg?branch=master)](https://travis-ci.org/epoberezkin/fast-deep-equal) +[![npm](https://img.shields.io/npm/v/fast-deep-equal.svg)](https://www.npmjs.com/package/fast-deep-equal) +[![Coverage Status](https://coveralls.io/repos/github/epoberezkin/fast-deep-equal/badge.svg?branch=master)](https://coveralls.io/github/epoberezkin/fast-deep-equal?branch=master) + + +## Install + +```bash +npm install fast-deep-equal +``` + + +## Features + +- ES5 compatible +- works in node.js (8+) and browsers (IE9+) +- checks equality of Date and RegExp objects by value. + +ES6 equal (`require('fast-deep-equal/es6')`) also supports: +- Maps +- Sets +- Typed arrays + + +## Usage + +```javascript +var equal = require('fast-deep-equal'); +console.log(equal({foo: 'bar'}, {foo: 'bar'})); // true +``` + +To support ES6 Maps, Sets and Typed arrays equality use: + +```javascript +var equal = require('fast-deep-equal/es6'); +console.log(equal(Int16Array([1, 2]), Int16Array([1, 2]))); // true +``` + +To use with React (avoiding the traversal of React elements' _owner +property that contains circular references and is not needed when +comparing the elements - borrowed from [react-fast-compare](https://github.com/FormidableLabs/react-fast-compare)): + +```javascript +var equal = require('fast-deep-equal/react'); +var equal = require('fast-deep-equal/es6/react'); +``` + + +## Performance benchmark + +Node.js v12.6.0: + +``` +fast-deep-equal x 261,950 ops/sec ±0.52% (89 runs sampled) +fast-deep-equal/es6 x 212,991 ops/sec ±0.34% (92 runs sampled) +fast-equals x 230,957 ops/sec ±0.83% (85 runs sampled) +nano-equal x 187,995 ops/sec ±0.53% (88 runs sampled) +shallow-equal-fuzzy x 138,302 ops/sec ±0.49% (90 runs sampled) +underscore.isEqual x 74,423 ops/sec ±0.38% (89 runs sampled) +lodash.isEqual x 36,637 ops/sec ±0.72% (90 runs sampled) +deep-equal x 2,310 ops/sec ±0.37% (90 runs sampled) +deep-eql x 35,312 ops/sec ±0.67% (91 runs sampled) +ramda.equals x 12,054 ops/sec ±0.40% (91 runs sampled) +util.isDeepStrictEqual x 46,440 ops/sec ±0.43% (90 runs sampled) +assert.deepStrictEqual x 456 ops/sec ±0.71% (88 runs sampled) + +The fastest is fast-deep-equal +``` + +To run benchmark (requires node.js 6+): + +```bash +npm run benchmark +``` + +__Please note__: this benchmark runs against the available test cases. To choose the most performant library for your application, it is recommended to benchmark against your data and to NOT expect this benchmark to reflect the performance difference in your application. + + +## Enterprise support + +fast-deep-equal package is a part of [Tidelift enterprise subscription](https://tidelift.com/subscription/pkg/npm-fast-deep-equal?utm_source=npm-fast-deep-equal&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) - it provides a centralised commercial support to open-source software users, in addition to the support provided by software maintainers. + + +## Security contact + +To report a security vulnerability, please use the +[Tidelift security contact](https://tidelift.com/security). +Tidelift will coordinate the fix and disclosure. Please do NOT report security vulnerability via GitHub issues. + + +## License + +[MIT](https://github.com/epoberezkin/fast-deep-equal/blob/master/LICENSE) diff --git a/tools/ui/node_modules/fast-deep-equal/es6/index.d.ts b/tools/ui/node_modules/fast-deep-equal/es6/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c7eb9c79694cccf3232d3830d9d67a6e200c0662 --- /dev/null +++ b/tools/ui/node_modules/fast-deep-equal/es6/index.d.ts @@ -0,0 +1,2 @@ +declare const equal: (a: any, b: any) => boolean; +export = equal; diff --git a/tools/ui/node_modules/fast-deep-equal/es6/index.js b/tools/ui/node_modules/fast-deep-equal/es6/index.js new file mode 100644 index 0000000000000000000000000000000000000000..d980be2575b7f06e7443bb3ec7023d63d2940c89 --- /dev/null +++ b/tools/ui/node_modules/fast-deep-equal/es6/index.js @@ -0,0 +1,72 @@ +'use strict'; + +// do not edit .js files directly - edit src/index.jst + + + var envHasBigInt64Array = typeof BigInt64Array !== 'undefined'; + + +module.exports = function equal(a, b) { + if (a === b) return true; + + if (a && b && typeof a == 'object' && typeof b == 'object') { + if (a.constructor !== b.constructor) return false; + + var length, i, keys; + if (Array.isArray(a)) { + length = a.length; + if (length != b.length) return false; + for (i = length; i-- !== 0;) + if (!equal(a[i], b[i])) return false; + return true; + } + + + if ((a instanceof Map) && (b instanceof Map)) { + if (a.size !== b.size) return false; + for (i of a.entries()) + if (!b.has(i[0])) return false; + for (i of a.entries()) + if (!equal(i[1], b.get(i[0]))) return false; + return true; + } + + if ((a instanceof Set) && (b instanceof Set)) { + if (a.size !== b.size) return false; + for (i of a.entries()) + if (!b.has(i[0])) return false; + return true; + } + + if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) { + length = a.length; + if (length != b.length) return false; + for (i = length; i-- !== 0;) + if (a[i] !== b[i]) return false; + return true; + } + + + if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags; + if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf(); + if (a.toString !== Object.prototype.toString) return a.toString() === b.toString(); + + keys = Object.keys(a); + length = keys.length; + if (length !== Object.keys(b).length) return false; + + for (i = length; i-- !== 0;) + if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; + + for (i = length; i-- !== 0;) { + var key = keys[i]; + + if (!equal(a[key], b[key])) return false; + } + + return true; + } + + // true if both NaN, false otherwise + return a!==a && b!==b; +}; diff --git a/tools/ui/node_modules/fast-deep-equal/es6/react.d.ts b/tools/ui/node_modules/fast-deep-equal/es6/react.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c7eb9c79694cccf3232d3830d9d67a6e200c0662 --- /dev/null +++ b/tools/ui/node_modules/fast-deep-equal/es6/react.d.ts @@ -0,0 +1,2 @@ +declare const equal: (a: any, b: any) => boolean; +export = equal; diff --git a/tools/ui/node_modules/fast-deep-equal/es6/react.js b/tools/ui/node_modules/fast-deep-equal/es6/react.js new file mode 100644 index 0000000000000000000000000000000000000000..98e2f9b71aa8bbf11b7f801814298276f9032541 --- /dev/null +++ b/tools/ui/node_modules/fast-deep-equal/es6/react.js @@ -0,0 +1,79 @@ +'use strict'; + +// do not edit .js files directly - edit src/index.jst + + + var envHasBigInt64Array = typeof BigInt64Array !== 'undefined'; + + +module.exports = function equal(a, b) { + if (a === b) return true; + + if (a && b && typeof a == 'object' && typeof b == 'object') { + if (a.constructor !== b.constructor) return false; + + var length, i, keys; + if (Array.isArray(a)) { + length = a.length; + if (length != b.length) return false; + for (i = length; i-- !== 0;) + if (!equal(a[i], b[i])) return false; + return true; + } + + + if ((a instanceof Map) && (b instanceof Map)) { + if (a.size !== b.size) return false; + for (i of a.entries()) + if (!b.has(i[0])) return false; + for (i of a.entries()) + if (!equal(i[1], b.get(i[0]))) return false; + return true; + } + + if ((a instanceof Set) && (b instanceof Set)) { + if (a.size !== b.size) return false; + for (i of a.entries()) + if (!b.has(i[0])) return false; + return true; + } + + if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) { + length = a.length; + if (length != b.length) return false; + for (i = length; i-- !== 0;) + if (a[i] !== b[i]) return false; + return true; + } + + + if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags; + if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf(); + if (a.toString !== Object.prototype.toString) return a.toString() === b.toString(); + + keys = Object.keys(a); + length = keys.length; + if (length !== Object.keys(b).length) return false; + + for (i = length; i-- !== 0;) + if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; + + for (i = length; i-- !== 0;) { + var key = keys[i]; + + if (key === '_owner' && a.$$typeof) { + // React-specific: avoid traversing React elements' _owner. + // _owner contains circular references + // and is not needed when comparing the actual elements (and not their owners) + continue; + } + + if (!equal(a[key], b[key])) return false; + } + + return true; + } + + // true if both NaN, false otherwise + return a!==a && b!==b; +}; diff --git a/tools/ui/node_modules/fast-deep-equal/index.d.ts b/tools/ui/node_modules/fast-deep-equal/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3c042caa7d5916def7b11fd3a4e910ddd379ff0c --- /dev/null +++ b/tools/ui/node_modules/fast-deep-equal/index.d.ts @@ -0,0 +1,4 @@ +declare module 'fast-deep-equal' { + const equal: (a: any, b: any) => boolean; + export = equal; +} diff --git a/tools/ui/node_modules/fast-deep-equal/index.js b/tools/ui/node_modules/fast-deep-equal/index.js new file mode 100644 index 0000000000000000000000000000000000000000..30dd1ba78cb4989e67a32295b3ca1fd9baaa6c96 --- /dev/null +++ b/tools/ui/node_modules/fast-deep-equal/index.js @@ -0,0 +1,46 @@ +'use strict'; + +// do not edit .js files directly - edit src/index.jst + + + +module.exports = function equal(a, b) { + if (a === b) return true; + + if (a && b && typeof a == 'object' && typeof b == 'object') { + if (a.constructor !== b.constructor) return false; + + var length, i, keys; + if (Array.isArray(a)) { + length = a.length; + if (length != b.length) return false; + for (i = length; i-- !== 0;) + if (!equal(a[i], b[i])) return false; + return true; + } + + + + if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags; + if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf(); + if (a.toString !== Object.prototype.toString) return a.toString() === b.toString(); + + keys = Object.keys(a); + length = keys.length; + if (length !== Object.keys(b).length) return false; + + for (i = length; i-- !== 0;) + if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; + + for (i = length; i-- !== 0;) { + var key = keys[i]; + + if (!equal(a[key], b[key])) return false; + } + + return true; + } + + // true if both NaN, false otherwise + return a!==a && b!==b; +}; diff --git a/tools/ui/node_modules/fast-deep-equal/package.json b/tools/ui/node_modules/fast-deep-equal/package.json new file mode 100644 index 0000000000000000000000000000000000000000..3cfe66c68e832bf5a728395ed493492e65737441 --- /dev/null +++ b/tools/ui/node_modules/fast-deep-equal/package.json @@ -0,0 +1,61 @@ +{ + "name": "fast-deep-equal", + "version": "3.1.3", + "description": "Fast deep equal", + "main": "index.js", + "scripts": { + "eslint": "eslint *.js benchmark/*.js spec/*.js", + "build": "node build", + "benchmark": "npm i && npm run build && cd ./benchmark && npm i && node ./", + "test-spec": "mocha spec/*.spec.js -R spec", + "test-cov": "nyc npm run test-spec", + "test-ts": "tsc --target ES5 --noImplicitAny index.d.ts", + "test": "npm run build && npm run eslint && npm run test-ts && npm run test-cov", + "prepublish": "npm run build" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/epoberezkin/fast-deep-equal.git" + }, + "keywords": [ + "fast", + "equal", + "deep-equal" + ], + "author": "Evgeny Poberezkin", + "license": "MIT", + "bugs": { + "url": "https://github.com/epoberezkin/fast-deep-equal/issues" + }, + "homepage": "https://github.com/epoberezkin/fast-deep-equal#readme", + "devDependencies": { + "coveralls": "^3.1.0", + "dot": "^1.1.2", + "eslint": "^7.2.0", + "mocha": "^7.2.0", + "nyc": "^15.1.0", + "pre-commit": "^1.2.2", + "react": "^16.12.0", + "react-test-renderer": "^16.12.0", + "sinon": "^9.0.2", + "typescript": "^3.9.5" + }, + "nyc": { + "exclude": [ + "**/spec/**", + "node_modules" + ], + "reporter": [ + "lcov", + "text-summary" + ] + }, + "files": [ + "index.js", + "index.d.ts", + "react.js", + "react.d.ts", + "es6/" + ], + "types": "index.d.ts" +} diff --git a/tools/ui/node_modules/fast-deep-equal/react.d.ts b/tools/ui/node_modules/fast-deep-equal/react.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c7eb9c79694cccf3232d3830d9d67a6e200c0662 --- /dev/null +++ b/tools/ui/node_modules/fast-deep-equal/react.d.ts @@ -0,0 +1,2 @@ +declare const equal: (a: any, b: any) => boolean; +export = equal; diff --git a/tools/ui/node_modules/fast-deep-equal/react.js b/tools/ui/node_modules/fast-deep-equal/react.js new file mode 100644 index 0000000000000000000000000000000000000000..3489b9833f3808dc78a17c5b34c5006176e93874 --- /dev/null +++ b/tools/ui/node_modules/fast-deep-equal/react.js @@ -0,0 +1,53 @@ +'use strict'; + +// do not edit .js files directly - edit src/index.jst + + + +module.exports = function equal(a, b) { + if (a === b) return true; + + if (a && b && typeof a == 'object' && typeof b == 'object') { + if (a.constructor !== b.constructor) return false; + + var length, i, keys; + if (Array.isArray(a)) { + length = a.length; + if (length != b.length) return false; + for (i = length; i-- !== 0;) + if (!equal(a[i], b[i])) return false; + return true; + } + + + + if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags; + if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf(); + if (a.toString !== Object.prototype.toString) return a.toString() === b.toString(); + + keys = Object.keys(a); + length = keys.length; + if (length !== Object.keys(b).length) return false; + + for (i = length; i-- !== 0;) + if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false; + + for (i = length; i-- !== 0;) { + var key = keys[i]; + + if (key === '_owner' && a.$$typeof) { + // React-specific: avoid traversing React elements' _owner. + // _owner contains circular references + // and is not needed when comparing the actual elements (and not their owners) + continue; + } + + if (!equal(a[key], b[key])) return false; + } + + return true; + } + + // true if both NaN, false otherwise + return a!==a && b!==b; +}; diff --git a/tools/ui/node_modules/fast-json-stable-stringify/.eslintrc.yml b/tools/ui/node_modules/fast-json-stable-stringify/.eslintrc.yml new file mode 100644 index 0000000000000000000000000000000000000000..1c77b0d479035958b213209cbb1f65092f17496b --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/.eslintrc.yml @@ -0,0 +1,26 @@ +extends: eslint:recommended +env: + node: true + browser: true +rules: + block-scoped-var: 2 + callback-return: 2 + dot-notation: 2 + indent: 2 + linebreak-style: [2, unix] + new-cap: 2 + no-console: [2, allow: [warn, error]] + no-else-return: 2 + no-eq-null: 2 + no-fallthrough: 2 + no-invalid-this: 2 + no-return-assign: 2 + no-shadow: 1 + no-trailing-spaces: 2 + no-use-before-define: [2, nofunc] + quotes: [2, single, avoid-escape] + semi: [2, always] + strict: [2, global] + valid-jsdoc: [2, requireReturn: false] + no-control-regex: 0 + no-useless-escape: 2 diff --git a/tools/ui/node_modules/fast-json-stable-stringify/.github/FUNDING.yml b/tools/ui/node_modules/fast-json-stable-stringify/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..61f9daa955b012ea7138d91cdd7470ed50523a07 --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/.github/FUNDING.yml @@ -0,0 +1 @@ +tidelift: "npm/fast-json-stable-stringify" diff --git a/tools/ui/node_modules/fast-json-stable-stringify/.travis.yml b/tools/ui/node_modules/fast-json-stable-stringify/.travis.yml new file mode 100644 index 0000000000000000000000000000000000000000..b61e8f0dc9dccdd5acdb9357ac635b715528effe --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/.travis.yml @@ -0,0 +1,8 @@ +language: node_js +node_js: + - "8" + - "10" + - "12" + - "13" +after_script: + - coveralls < coverage/lcov.info diff --git a/tools/ui/node_modules/fast-json-stable-stringify/LICENSE b/tools/ui/node_modules/fast-json-stable-stringify/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..c932223b1e2c2f3ca84e318c83ce4ce5201ebd5b --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/LICENSE @@ -0,0 +1,21 @@ +This software is released under the MIT license: + +Copyright (c) 2017 Evgeny Poberezkin +Copyright (c) 2013 James Halliday + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR +COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN +CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/fast-json-stable-stringify/README.md b/tools/ui/node_modules/fast-json-stable-stringify/README.md new file mode 100644 index 0000000000000000000000000000000000000000..02cf49ff385b8bd478b67c2e2392f2e392d8926a --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/README.md @@ -0,0 +1,131 @@ +# fast-json-stable-stringify + +Deterministic `JSON.stringify()` - a faster version of [@substack](https://github.com/substack)'s json-stable-strigify without [jsonify](https://github.com/substack/jsonify). + +You can also pass in a custom comparison function. + +[![Build Status](https://travis-ci.org/epoberezkin/fast-json-stable-stringify.svg?branch=master)](https://travis-ci.org/epoberezkin/fast-json-stable-stringify) +[![Coverage Status](https://coveralls.io/repos/github/epoberezkin/fast-json-stable-stringify/badge.svg?branch=master)](https://coveralls.io/github/epoberezkin/fast-json-stable-stringify?branch=master) + +# example + +``` js +var stringify = require('fast-json-stable-stringify'); +var obj = { c: 8, b: [{z:6,y:5,x:4},7], a: 3 }; +console.log(stringify(obj)); +``` + +output: + +``` +{"a":3,"b":[{"x":4,"y":5,"z":6},7],"c":8} +``` + + +# methods + +``` js +var stringify = require('fast-json-stable-stringify') +``` + +## var str = stringify(obj, opts) + +Return a deterministic stringified string `str` from the object `obj`. + + +## options + +### cmp + +If `opts` is given, you can supply an `opts.cmp` to have a custom comparison +function for object keys. Your function `opts.cmp` is called with these +parameters: + +``` js +opts.cmp({ key: akey, value: avalue }, { key: bkey, value: bvalue }) +``` + +For example, to sort on the object key names in reverse order you could write: + +``` js +var stringify = require('fast-json-stable-stringify'); + +var obj = { c: 8, b: [{z:6,y:5,x:4},7], a: 3 }; +var s = stringify(obj, function (a, b) { + return a.key < b.key ? 1 : -1; +}); +console.log(s); +``` + +which results in the output string: + +``` +{"c":8,"b":[{"z":6,"y":5,"x":4},7],"a":3} +``` + +Or if you wanted to sort on the object values in reverse order, you could write: + +``` +var stringify = require('fast-json-stable-stringify'); + +var obj = { d: 6, c: 5, b: [{z:3,y:2,x:1},9], a: 10 }; +var s = stringify(obj, function (a, b) { + return a.value < b.value ? 1 : -1; +}); +console.log(s); +``` + +which outputs: + +``` +{"d":6,"c":5,"b":[{"z":3,"y":2,"x":1},9],"a":10} +``` + +### cycles + +Pass `true` in `opts.cycles` to stringify circular property as `__cycle__` - the result will not be a valid JSON string in this case. + +TypeError will be thrown in case of circular object without this option. + + +# install + +With [npm](https://npmjs.org) do: + +``` +npm install fast-json-stable-stringify +``` + + +# benchmark + +To run benchmark (requires Node.js 6+): +``` +node benchmark +``` + +Results: +``` +fast-json-stable-stringify x 17,189 ops/sec ±1.43% (83 runs sampled) +json-stable-stringify x 13,634 ops/sec ±1.39% (85 runs sampled) +fast-stable-stringify x 20,212 ops/sec ±1.20% (84 runs sampled) +faster-stable-stringify x 15,549 ops/sec ±1.12% (84 runs sampled) +The fastest is fast-stable-stringify +``` + + +## Enterprise support + +fast-json-stable-stringify package is a part of [Tidelift enterprise subscription](https://tidelift.com/subscription/pkg/npm-fast-json-stable-stringify?utm_source=npm-fast-json-stable-stringify&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) - it provides a centralised commercial support to open-source software users, in addition to the support provided by software maintainers. + + +## Security contact + +To report a security vulnerability, please use the +[Tidelift security contact](https://tidelift.com/security). +Tidelift will coordinate the fix and disclosure. Please do NOT report security vulnerability via GitHub issues. + + +# license + +[MIT](https://github.com/epoberezkin/fast-json-stable-stringify/blob/master/LICENSE) diff --git a/tools/ui/node_modules/fast-json-stable-stringify/benchmark/index.js b/tools/ui/node_modules/fast-json-stable-stringify/benchmark/index.js new file mode 100644 index 0000000000000000000000000000000000000000..e725f9fc5f1e8fe9ba16c9b4df47aae9b2162a25 --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/benchmark/index.js @@ -0,0 +1,31 @@ +'use strict'; + +const Benchmark = require('benchmark'); +const suite = new Benchmark.Suite; +const testData = require('./test.json'); + + +const stringifyPackages = { + // 'JSON.stringify': JSON.stringify, + 'fast-json-stable-stringify': require('../index'), + 'json-stable-stringify': true, + 'fast-stable-stringify': true, + 'faster-stable-stringify': true +}; + + +for (const name in stringifyPackages) { + let func = stringifyPackages[name]; + if (func === true) func = require(name); + + suite.add(name, function() { + func(testData); + }); +} + +suite + .on('cycle', (event) => console.log(String(event.target))) + .on('complete', function () { + console.log('The fastest is ' + this.filter('fastest').map('name')); + }) + .run({async: true}); diff --git a/tools/ui/node_modules/fast-json-stable-stringify/benchmark/test.json b/tools/ui/node_modules/fast-json-stable-stringify/benchmark/test.json new file mode 100644 index 0000000000000000000000000000000000000000..c9118c11f5905b57f4d954209abad70de3e9e56a --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/benchmark/test.json @@ -0,0 +1,137 @@ +[ + { + "_id": "59ef4a83ee8364808d761beb", + "index": 0, + "guid": "e50ffae9-7128-4148-9ee5-40c3fc523c5d", + "isActive": false, + "balance": "$2,341.81", + "picture": "http://placehold.it/32x32", + "age": 28, + "eyeColor": "brown", + "name": "Carey Savage", + "gender": "female", + "company": "VERAQ", + "email": "careysavage@veraq.com", + "phone": "+1 (897) 574-3014", + "address": "458 Willow Street, Henrietta, California, 7234", + "about": "Nisi reprehenderit nulla ad officia pariatur non dolore laboris irure cupidatat laborum. Minim eu ex Lorem adipisicing exercitation irure minim sunt est enim mollit incididunt voluptate nulla. Ut mollit anim reprehenderit et aliqua ex esse aliquip. Aute sit duis deserunt do incididunt consequat minim qui dolor commodo deserunt et voluptate.\r\n", + "registered": "2014-05-21T01:56:51 -01:00", + "latitude": 63.89502, + "longitude": 62.369807, + "tags": [ + "nostrud", + "nisi", + "consectetur", + "ullamco", + "cupidatat", + "culpa", + "commodo" + ], + "friends": [ + { + "id": 0, + "name": "Henry Walls" + }, + { + "id": 1, + "name": "Janice Baker" + }, + { + "id": 2, + "name": "Russell Bush" + } + ], + "greeting": "Hello, Carey Savage! You have 4 unread messages.", + "favoriteFruit": "banana" + }, + { + "_id": "59ef4a83ff5774a691454e89", + "index": 1, + "guid": "2bee9efc-4095-4c2e-87ef-d08c8054c89d", + "isActive": true, + "balance": "$1,618.15", + "picture": "http://placehold.it/32x32", + "age": 35, + "eyeColor": "blue", + "name": "Elinor Pearson", + "gender": "female", + "company": "FLEXIGEN", + "email": "elinorpearson@flexigen.com", + "phone": "+1 (923) 548-3751", + "address": "600 Bayview Avenue, Draper, Montana, 3088", + "about": "Mollit commodo ea sit Lorem velit. Irure anim esse Lorem sint quis officia ut. Aliqua nisi dolore in aute deserunt mollit ex ea in mollit.\r\n", + "registered": "2017-04-22T07:58:41 -01:00", + "latitude": -87.824919, + "longitude": 69.538927, + "tags": [ + "fugiat", + "labore", + "proident", + "quis", + "eiusmod", + "qui", + "est" + ], + "friends": [ + { + "id": 0, + "name": "Massey Wagner" + }, + { + "id": 1, + "name": "Marcella Ferrell" + }, + { + "id": 2, + "name": "Evans Mckee" + } + ], + "greeting": "Hello, Elinor Pearson! You have 3 unread messages.", + "favoriteFruit": "strawberry" + }, + { + "_id": "59ef4a839ec8a4be4430b36b", + "index": 2, + "guid": "ddd6e8c0-95bd-416d-8b46-a768d6363809", + "isActive": false, + "balance": "$2,046.95", + "picture": "http://placehold.it/32x32", + "age": 40, + "eyeColor": "green", + "name": "Irwin Davidson", + "gender": "male", + "company": "DANJA", + "email": "irwindavidson@danja.com", + "phone": "+1 (883) 537-2041", + "address": "439 Cook Street, Chapin, Kentucky, 7398", + "about": "Irure velit non commodo aliqua exercitation ut nostrud minim magna. Dolor ad ad ut irure eu. Non pariatur dolor eiusmod ipsum do et exercitation cillum. Et amet laboris minim eiusmod ullamco magna ea reprehenderit proident sunt.\r\n", + "registered": "2016-09-01T07:49:08 -01:00", + "latitude": -49.803812, + "longitude": 104.93279, + "tags": [ + "consequat", + "enim", + "quis", + "magna", + "est", + "culpa", + "tempor" + ], + "friends": [ + { + "id": 0, + "name": "Ruth Hansen" + }, + { + "id": 1, + "name": "Kathrine Austin" + }, + { + "id": 2, + "name": "Rivera Munoz" + } + ], + "greeting": "Hello, Irwin Davidson! You have 2 unread messages.", + "favoriteFruit": "banana" + } +] diff --git a/tools/ui/node_modules/fast-json-stable-stringify/example/key_cmp.js b/tools/ui/node_modules/fast-json-stable-stringify/example/key_cmp.js new file mode 100644 index 0000000000000000000000000000000000000000..d5f66752d82e15116b68c731ce0751e8799c3d5e --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/example/key_cmp.js @@ -0,0 +1,7 @@ +var stringify = require('../'); + +var obj = { c: 8, b: [{z:6,y:5,x:4},7], a: 3 }; +var s = stringify(obj, function (a, b) { + return a.key < b.key ? 1 : -1; +}); +console.log(s); diff --git a/tools/ui/node_modules/fast-json-stable-stringify/example/nested.js b/tools/ui/node_modules/fast-json-stable-stringify/example/nested.js new file mode 100644 index 0000000000000000000000000000000000000000..9a672fc65fb0fcf3112e578571df647a1acf0f46 --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/example/nested.js @@ -0,0 +1,3 @@ +var stringify = require('../'); +var obj = { c: 8, b: [{z:6,y:5,x:4},7], a: 3 }; +console.log(stringify(obj)); diff --git a/tools/ui/node_modules/fast-json-stable-stringify/example/str.js b/tools/ui/node_modules/fast-json-stable-stringify/example/str.js new file mode 100644 index 0000000000000000000000000000000000000000..9b4b3cd289570ec16943219e4a076ca1a767924b --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/example/str.js @@ -0,0 +1,3 @@ +var stringify = require('../'); +var obj = { c: 6, b: [4,5], a: 3 }; +console.log(stringify(obj)); diff --git a/tools/ui/node_modules/fast-json-stable-stringify/example/value_cmp.js b/tools/ui/node_modules/fast-json-stable-stringify/example/value_cmp.js new file mode 100644 index 0000000000000000000000000000000000000000..09f1c5f79b2167308e0aae89de38d79fcdf52624 --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/example/value_cmp.js @@ -0,0 +1,7 @@ +var stringify = require('../'); + +var obj = { d: 6, c: 5, b: [{z:3,y:2,x:1},9], a: 10 }; +var s = stringify(obj, function (a, b) { + return a.value < b.value ? 1 : -1; +}); +console.log(s); diff --git a/tools/ui/node_modules/fast-json-stable-stringify/index.d.ts b/tools/ui/node_modules/fast-json-stable-stringify/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..23e46cafc140a3ed99104ba1997f34b2414f9ef4 --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/index.d.ts @@ -0,0 +1,4 @@ +declare module 'fast-json-stable-stringify' { + function stringify(obj: any): string; + export = stringify; +} diff --git a/tools/ui/node_modules/fast-json-stable-stringify/index.js b/tools/ui/node_modules/fast-json-stable-stringify/index.js new file mode 100644 index 0000000000000000000000000000000000000000..c44e6a4137212cc1c577b8499bf963de2eda00e5 --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/index.js @@ -0,0 +1,59 @@ +'use strict'; + +module.exports = function (data, opts) { + if (!opts) opts = {}; + if (typeof opts === 'function') opts = { cmp: opts }; + var cycles = (typeof opts.cycles === 'boolean') ? opts.cycles : false; + + var cmp = opts.cmp && (function (f) { + return function (node) { + return function (a, b) { + var aobj = { key: a, value: node[a] }; + var bobj = { key: b, value: node[b] }; + return f(aobj, bobj); + }; + }; + })(opts.cmp); + + var seen = []; + return (function stringify (node) { + if (node && node.toJSON && typeof node.toJSON === 'function') { + node = node.toJSON(); + } + + if (node === undefined) return; + if (typeof node == 'number') return isFinite(node) ? '' + node : 'null'; + if (typeof node !== 'object') return JSON.stringify(node); + + var i, out; + if (Array.isArray(node)) { + out = '['; + for (i = 0; i < node.length; i++) { + if (i) out += ','; + out += stringify(node[i]) || 'null'; + } + return out + ']'; + } + + if (node === null) return 'null'; + + if (seen.indexOf(node) !== -1) { + if (cycles) return JSON.stringify('__cycle__'); + throw new TypeError('Converting circular structure to JSON'); + } + + var seenIndex = seen.push(node) - 1; + var keys = Object.keys(node).sort(cmp && cmp(node)); + out = ''; + for (i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = stringify(node[key]); + + if (!value) continue; + if (out) out += ','; + out += JSON.stringify(key) + ':' + value; + } + seen.splice(seenIndex, 1); + return '{' + out + '}'; + })(data); +}; diff --git a/tools/ui/node_modules/fast-json-stable-stringify/package.json b/tools/ui/node_modules/fast-json-stable-stringify/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ad2c8bff7c94e2f361b6245146a51667c6c27dc4 --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/package.json @@ -0,0 +1,52 @@ +{ + "name": "fast-json-stable-stringify", + "version": "2.1.0", + "description": "deterministic `JSON.stringify()` - a faster version of substack's json-stable-strigify without jsonify", + "main": "index.js", + "types": "index.d.ts", + "dependencies": {}, + "devDependencies": { + "benchmark": "^2.1.4", + "coveralls": "^3.0.0", + "eslint": "^6.7.0", + "fast-stable-stringify": "latest", + "faster-stable-stringify": "latest", + "json-stable-stringify": "latest", + "nyc": "^14.1.0", + "pre-commit": "^1.2.2", + "tape": "^4.11.0" + }, + "scripts": { + "eslint": "eslint index.js test", + "test-spec": "tape test/*.js", + "test": "npm run eslint && nyc npm run test-spec" + }, + "repository": { + "type": "git", + "url": "git://github.com/epoberezkin/fast-json-stable-stringify.git" + }, + "homepage": "https://github.com/epoberezkin/fast-json-stable-stringify", + "keywords": [ + "json", + "stringify", + "deterministic", + "hash", + "stable" + ], + "author": { + "name": "James Halliday", + "email": "mail@substack.net", + "url": "http://substack.net" + }, + "license": "MIT", + "nyc": { + "exclude": [ + "test", + "node_modules" + ], + "reporter": [ + "lcov", + "text-summary" + ] + } +} diff --git a/tools/ui/node_modules/fast-json-stable-stringify/test/cmp.js b/tools/ui/node_modules/fast-json-stable-stringify/test/cmp.js new file mode 100644 index 0000000000000000000000000000000000000000..4efd6b59721f9f875aa8ec869293fa398569c555 --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/test/cmp.js @@ -0,0 +1,13 @@ +'use strict'; + +var test = require('tape'); +var stringify = require('../'); + +test('custom comparison function', function (t) { + t.plan(1); + var obj = { c: 8, b: [{z:6,y:5,x:4},7], a: 3 }; + var s = stringify(obj, function (a, b) { + return a.key < b.key ? 1 : -1; + }); + t.equal(s, '{"c":8,"b":[{"z":6,"y":5,"x":4},7],"a":3}'); +}); diff --git a/tools/ui/node_modules/fast-json-stable-stringify/test/nested.js b/tools/ui/node_modules/fast-json-stable-stringify/test/nested.js new file mode 100644 index 0000000000000000000000000000000000000000..167a358e09a2963784915cf0272b128de8d3d1e5 --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/test/nested.js @@ -0,0 +1,44 @@ +'use strict'; + +var test = require('tape'); +var stringify = require('../'); + +test('nested', function (t) { + t.plan(1); + var obj = { c: 8, b: [{z:6,y:5,x:4},7], a: 3 }; + t.equal(stringify(obj), '{"a":3,"b":[{"x":4,"y":5,"z":6},7],"c":8}'); +}); + +test('cyclic (default)', function (t) { + t.plan(1); + var one = { a: 1 }; + var two = { a: 2, one: one }; + one.two = two; + try { + stringify(one); + } catch (ex) { + t.equal(ex.toString(), 'TypeError: Converting circular structure to JSON'); + } +}); + +test('cyclic (specifically allowed)', function (t) { + t.plan(1); + var one = { a: 1 }; + var two = { a: 2, one: one }; + one.two = two; + t.equal(stringify(one, {cycles:true}), '{"a":1,"two":{"a":2,"one":"__cycle__"}}'); +}); + +test('repeated non-cyclic value', function(t) { + t.plan(1); + var one = { x: 1 }; + var two = { a: one, b: one }; + t.equal(stringify(two), '{"a":{"x":1},"b":{"x":1}}'); +}); + +test('acyclic but with reused obj-property pointers', function (t) { + t.plan(1); + var x = { a: 1 }; + var y = { b: x, c: x }; + t.equal(stringify(y), '{"b":{"a":1},"c":{"a":1}}'); +}); diff --git a/tools/ui/node_modules/fast-json-stable-stringify/test/str.js b/tools/ui/node_modules/fast-json-stable-stringify/test/str.js new file mode 100644 index 0000000000000000000000000000000000000000..99a9ade18bb85760a173ffbc76e6d51ae0a25eaf --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/test/str.js @@ -0,0 +1,46 @@ +'use strict'; + +var test = require('tape'); +var stringify = require('../'); + +test('simple object', function (t) { + t.plan(1); + var obj = { c: 6, b: [4,5], a: 3, z: null }; + t.equal(stringify(obj), '{"a":3,"b":[4,5],"c":6,"z":null}'); +}); + +test('object with undefined', function (t) { + t.plan(1); + var obj = { a: 3, z: undefined }; + t.equal(stringify(obj), '{"a":3}'); +}); + +test('object with null', function (t) { + t.plan(1); + var obj = { a: 3, z: null }; + t.equal(stringify(obj), '{"a":3,"z":null}'); +}); + +test('object with NaN and Infinity', function (t) { + t.plan(1); + var obj = { a: 3, b: NaN, c: Infinity }; + t.equal(stringify(obj), '{"a":3,"b":null,"c":null}'); +}); + +test('array with undefined', function (t) { + t.plan(1); + var obj = [4, undefined, 6]; + t.equal(stringify(obj), '[4,null,6]'); +}); + +test('object with empty string', function (t) { + t.plan(1); + var obj = { a: 3, z: '' }; + t.equal(stringify(obj), '{"a":3,"z":""}'); +}); + +test('array with empty string', function (t) { + t.plan(1); + var obj = [4, '', 6]; + t.equal(stringify(obj), '[4,"",6]'); +}); diff --git a/tools/ui/node_modules/fast-json-stable-stringify/test/to-json.js b/tools/ui/node_modules/fast-json-stable-stringify/test/to-json.js new file mode 100644 index 0000000000000000000000000000000000000000..2fb2cfa3e8754a5d84eab3c61968d4af441ae217 --- /dev/null +++ b/tools/ui/node_modules/fast-json-stable-stringify/test/to-json.js @@ -0,0 +1,22 @@ +'use strict'; + +var test = require('tape'); +var stringify = require('../'); + +test('toJSON function', function (t) { + t.plan(1); + var obj = { one: 1, two: 2, toJSON: function() { return { one: 1 }; } }; + t.equal(stringify(obj), '{"one":1}' ); +}); + +test('toJSON returns string', function (t) { + t.plan(1); + var obj = { one: 1, two: 2, toJSON: function() { return 'one'; } }; + t.equal(stringify(obj), '"one"'); +}); + +test('toJSON returns array', function (t) { + t.plan(1); + var obj = { one: 1, two: 2, toJSON: function() { return ['one']; } }; + t.equal(stringify(obj), '["one"]'); +}); diff --git a/tools/ui/node_modules/fast-levenshtein/LICENSE.md b/tools/ui/node_modules/fast-levenshtein/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..6212406b413b7a8942c0978b1c05f9d224755ae8 --- /dev/null +++ b/tools/ui/node_modules/fast-levenshtein/LICENSE.md @@ -0,0 +1,25 @@ +(MIT License) + +Copyright (c) 2013 [Ramesh Nair](http://www.hiddentao.com/) + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + diff --git a/tools/ui/node_modules/fast-levenshtein/README.md b/tools/ui/node_modules/fast-levenshtein/README.md new file mode 100644 index 0000000000000000000000000000000000000000..a77899539693981ee42fc78446605a9c8af5bda3 --- /dev/null +++ b/tools/ui/node_modules/fast-levenshtein/README.md @@ -0,0 +1,104 @@ +# fast-levenshtein - Levenshtein algorithm in Javascript + +[![Build Status](https://secure.travis-ci.org/hiddentao/fast-levenshtein.png)](http://travis-ci.org/hiddentao/fast-levenshtein) +[![NPM module](https://badge.fury.io/js/fast-levenshtein.png)](https://badge.fury.io/js/fast-levenshtein) +[![NPM downloads](https://img.shields.io/npm/dm/fast-levenshtein.svg?maxAge=2592000)](https://www.npmjs.com/package/fast-levenshtein) +[![Follow on Twitter](https://img.shields.io/twitter/url/http/shields.io.svg?style=social&label=Follow&maxAge=2592000)](https://twitter.com/hiddentao) + +An efficient Javascript implementation of the [Levenshtein algorithm](http://en.wikipedia.org/wiki/Levenshtein_distance) with locale-specific collator support. + +## Features + +* Works in node.js and in the browser. +* Better performance than other implementations by not needing to store the whole matrix ([more info](http://www.codeproject.com/Articles/13525/Fast-memory-efficient-Levenshtein-algorithm)). +* Locale-sensitive string comparisions if needed. +* Comprehensive test suite and performance benchmark. +* Small: <1 KB minified and gzipped + +## Installation + +### node.js + +Install using [npm](http://npmjs.org/): + +```bash +$ npm install fast-levenshtein +``` + +### Browser + +Using bower: + +```bash +$ bower install fast-levenshtein +``` + +If you are not using any module loader system then the API will then be accessible via the `window.Levenshtein` object. + +## Examples + +**Default usage** + +```javascript +var levenshtein = require('fast-levenshtein'); + +var distance = levenshtein.get('back', 'book'); // 2 +var distance = levenshtein.get('我愛你', '我叫你'); // 1 +``` + +**Locale-sensitive string comparisons** + +It supports using [Intl.Collator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Collator) for locale-sensitive string comparisons: + +```javascript +var levenshtein = require('fast-levenshtein'); + +levenshtein.get('mikailovitch', 'Mikhaïlovitch', { useCollator: true}); +// 1 +``` + +## Building and Testing + +To build the code and run the tests: + +```bash +$ npm install -g grunt-cli +$ npm install +$ npm run build +``` + +## Performance + +_Thanks to [Titus Wormer](https://github.com/wooorm) for [encouraging me](https://github.com/hiddentao/fast-levenshtein/issues/1) to do this._ + +Benchmarked against other node.js levenshtein distance modules (on Macbook Air 2012, Core i7, 8GB RAM): + +```bash +Running suite Implementation comparison [benchmark/speed.js]... +>> levenshtein-edit-distance x 234 ops/sec ±3.02% (73 runs sampled) +>> levenshtein-component x 422 ops/sec ±4.38% (83 runs sampled) +>> levenshtein-deltas x 283 ops/sec ±3.83% (78 runs sampled) +>> natural x 255 ops/sec ±0.76% (88 runs sampled) +>> levenshtein x 180 ops/sec ±3.55% (86 runs sampled) +>> fast-levenshtein x 1,792 ops/sec ±2.72% (95 runs sampled) +Benchmark done. +Fastest test is fast-levenshtein at 4.2x faster than levenshtein-component +``` + +You can run this benchmark yourself by doing: + +```bash +$ npm install +$ npm run build +$ npm run benchmark +``` + +## Contributing + +If you wish to submit a pull request please update and/or create new tests for any changes you make and ensure the grunt build passes. + +See [CONTRIBUTING.md](https://github.com/hiddentao/fast-levenshtein/blob/master/CONTRIBUTING.md) for details. + +## License + +MIT - see [LICENSE.md](https://github.com/hiddentao/fast-levenshtein/blob/master/LICENSE.md) diff --git a/tools/ui/node_modules/fast-levenshtein/levenshtein.js b/tools/ui/node_modules/fast-levenshtein/levenshtein.js new file mode 100644 index 0000000000000000000000000000000000000000..dbe3628080f551981de5389f33bec4af9bfb1ef7 --- /dev/null +++ b/tools/ui/node_modules/fast-levenshtein/levenshtein.js @@ -0,0 +1,136 @@ +(function() { + 'use strict'; + + var collator; + try { + collator = (typeof Intl !== "undefined" && typeof Intl.Collator !== "undefined") ? Intl.Collator("generic", { sensitivity: "base" }) : null; + } catch (err){ + console.log("Collator could not be initialized and wouldn't be used"); + } + // arrays to re-use + var prevRow = [], + str2Char = []; + + /** + * Based on the algorithm at http://en.wikipedia.org/wiki/Levenshtein_distance. + */ + var Levenshtein = { + /** + * Calculate levenshtein distance of the two strings. + * + * @param str1 String the first string. + * @param str2 String the second string. + * @param [options] Additional options. + * @param [options.useCollator] Use `Intl.Collator` for locale-sensitive string comparison. + * @return Integer the levenshtein distance (0 and above). + */ + get: function(str1, str2, options) { + var useCollator = (options && collator && options.useCollator); + + var str1Len = str1.length, + str2Len = str2.length; + + // base cases + if (str1Len === 0) return str2Len; + if (str2Len === 0) return str1Len; + + // two rows + var curCol, nextCol, i, j, tmp; + + // initialise previous row + for (i=0; i tmp) { + nextCol = tmp; + } + // deletion + tmp = prevRow[j + 1] + 1; + if (nextCol > tmp) { + nextCol = tmp; + } + + // copy current col value into previous (in preparation for next iteration) + prevRow[j] = curCol; + } + + // copy last col value into previous (in preparation for next iteration) + prevRow[j] = nextCol; + } + } + else { + // calculate current row distance from previous row without collator + for (i = 0; i < str1Len; ++i) { + nextCol = i + 1; + + for (j = 0; j < str2Len; ++j) { + curCol = nextCol; + + // substution + strCmp = str1.charCodeAt(i) === str2Char[j]; + + nextCol = prevRow[j] + (strCmp ? 0 : 1); + + // insertion + tmp = curCol + 1; + if (nextCol > tmp) { + nextCol = tmp; + } + // deletion + tmp = prevRow[j + 1] + 1; + if (nextCol > tmp) { + nextCol = tmp; + } + + // copy current col value into previous (in preparation for next iteration) + prevRow[j] = curCol; + } + + // copy last col value into previous (in preparation for next iteration) + prevRow[j] = nextCol; + } + } + return nextCol; + } + + }; + + // amd + if (typeof define !== "undefined" && define !== null && define.amd) { + define(function() { + return Levenshtein; + }); + } + // commonjs + else if (typeof module !== "undefined" && module !== null && typeof exports !== "undefined" && module.exports === exports) { + module.exports = Levenshtein; + } + // web worker + else if (typeof self !== "undefined" && typeof self.postMessage === 'function' && typeof self.importScripts === 'function') { + self.Levenshtein = Levenshtein; + } + // browser main thread + else if (typeof window !== "undefined" && window !== null) { + window.Levenshtein = Levenshtein; + } +}()); + diff --git a/tools/ui/node_modules/fast-levenshtein/package.json b/tools/ui/node_modules/fast-levenshtein/package.json new file mode 100644 index 0000000000000000000000000000000000000000..5b4736d4537a5e11d2ada0ef4075a45c8e1d4040 --- /dev/null +++ b/tools/ui/node_modules/fast-levenshtein/package.json @@ -0,0 +1,39 @@ +{ + "name": "fast-levenshtein", + "version": "2.0.6", + "description": "Efficient implementation of Levenshtein algorithm with locale-specific collator support.", + "main": "levenshtein.js", + "files": [ + "levenshtein.js" + ], + "scripts": { + "build": "grunt build", + "prepublish": "npm run build", + "benchmark": "grunt benchmark", + "test": "mocha" + }, + "devDependencies": { + "chai": "~1.5.0", + "grunt": "~0.4.1", + "grunt-benchmark": "~0.2.0", + "grunt-cli": "^1.2.0", + "grunt-contrib-jshint": "~0.4.3", + "grunt-contrib-uglify": "~0.2.0", + "grunt-mocha-test": "~0.2.2", + "grunt-npm-install": "~0.1.0", + "load-grunt-tasks": "~0.6.0", + "lodash": "^4.0.1", + "mocha": "~1.9.0" + }, + "repository": { + "type": "git", + "url": "https://github.com/hiddentao/fast-levenshtein.git" + }, + "keywords": [ + "levenshtein", + "distance", + "string" + ], + "author": "Ramesh Nair (http://www.hiddentao.com/)", + "license": "MIT" +} diff --git a/tools/ui/node_modules/fast-uri/.gitattributes b/tools/ui/node_modules/fast-uri/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..a0e7df931f90e194cc6b80313f8f07744d9fc6d8 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/.gitattributes @@ -0,0 +1,2 @@ +# Set default behavior to automatically convert line endings +* text=auto eol=lf diff --git a/tools/ui/node_modules/fast-uri/.github/dependabot.yml b/tools/ui/node_modules/fast-uri/.github/dependabot.yml new file mode 100644 index 0000000000000000000000000000000000000000..35d66ca7ac75f125b9c9c5b3dee0987fdfca4a45 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/.github/dependabot.yml @@ -0,0 +1,13 @@ +version: 2 +updates: + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "monthly" + open-pull-requests-limit: 10 + + - package-ecosystem: "npm" + directory: "/" + schedule: + interval: "monthly" + open-pull-requests-limit: 10 diff --git a/tools/ui/node_modules/fast-uri/.github/workflows/ci.yml b/tools/ui/node_modules/fast-uri/.github/workflows/ci.yml new file mode 100644 index 0000000000000000000000000000000000000000..a7169f5880aa0c6d6f454c4bc796b3c582541afe --- /dev/null +++ b/tools/ui/node_modules/fast-uri/.github/workflows/ci.yml @@ -0,0 +1,106 @@ +name: CI + +on: + push: + branches: + - main + - next + - 'v*' + paths-ignore: + - 'docs/**' + - '*.md' + pull_request: + paths-ignore: + - 'docs/**' + - '*.md' + +# This allows a subsequently queued workflow run to interrupt previous runs +concurrency: + group: "${{ github.workflow }}-${{ github.event.pull_request.head.label || github.head_ref || github.ref }}" + cancel-in-progress: true + +permissions: + contents: read + +jobs: + test-regression-check-node10: + name: Test compatibility with Node.js 10 + runs-on: ubuntu-latest + permissions: + contents: read + steps: + - uses: actions/checkout@v6 + with: + persist-credentials: false + + - uses: actions/setup-node@v6 + with: + node-version: '10' + cache: 'npm' + cache-dependency-path: package.json + check-latest: true + + - name: Install + run: | + npm install --ignore-scripts + + - name: Copy project as fast-uri to node_node_modules + run: | + rm -rf ./node_modules/fast-uri/lib && + rm -rf ./node_modules/fast-uri/index.js && + cp -r ./lib ./node_modules/fast-uri/lib && + cp ./index.js ./node_modules/fast-uri/index.js + + - name: Run tests + run: | + npm run test:unit + env: + NODE_OPTIONS: no-network-family-autoselection + + test-browser: + name: Test browser compatibility + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + os: ['ubuntu-latest', 'windows-latest', 'macos-latest'] + browser: ['chromium', 'firefox', 'webkit'] + exclude: + - os: ubuntu-latest + browser: webkit + permissions: + contents: read + steps: + - uses: actions/checkout@v6 + with: + persist-credentials: false + + - uses: actions/setup-node@v6 + with: + node-version: '24' + cache: 'npm' + cache-dependency-path: package.json + check-latest: true + + - name: Install dependencies + run: | + npm install --ignore-scripts + + - if: ${{ matrix.os == 'windows-latest' }} + run: npx playwright install winldd + + - name: Run browser tests + run: | + npm run test:browser:${{ matrix.browser }} + + test: + needs: + - test-regression-check-node10 + permissions: + contents: write + pull-requests: write + uses: fastify/workflows/.github/workflows/plugins-ci.yml@v6 + with: + license-check: true + lint: true + node-versions: '["16", "18", "20", "22", "24"]' diff --git a/tools/ui/node_modules/fast-uri/.github/workflows/lock-threads.yml b/tools/ui/node_modules/fast-uri/.github/workflows/lock-threads.yml new file mode 100644 index 0000000000000000000000000000000000000000..bd263f2d60cf77f81ba53f16f97ca95ddee0ab27 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/.github/workflows/lock-threads.yml @@ -0,0 +1,19 @@ +name: Lock Threads + +on: + schedule: + - cron: '0 0 1 * *' + workflow_dispatch: + +concurrency: + group: lock + +permissions: + contents: read + +jobs: + lock-threads: + permissions: + issues: write + pull-requests: write + uses: fastify/workflows/.github/workflows/lock-threads.yml@v6 diff --git a/tools/ui/node_modules/fast-uri/.github/workflows/package-manager-ci.yml b/tools/ui/node_modules/fast-uri/.github/workflows/package-manager-ci.yml new file mode 100644 index 0000000000000000000000000000000000000000..7a33f682928186a4f63cd7611be82c0f5a97aaf6 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/.github/workflows/package-manager-ci.yml @@ -0,0 +1,24 @@ +name: package-manager-ci + +on: + push: + branches: + - main + - next + - 'v*' + paths-ignore: + - 'docs/**' + - '*.md' + pull_request: + paths-ignore: + - 'docs/**' + - '*.md' + +permissions: + contents: read + +jobs: + test: + permissions: + contents: read + uses: fastify/workflows/.github/workflows/plugins-ci-package-manager.yml@v6 diff --git a/tools/ui/node_modules/fast-uri/LICENSE b/tools/ui/node_modules/fast-uri/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..9c93c1c0e5c1861b77da95d4cfb96504768285bc --- /dev/null +++ b/tools/ui/node_modules/fast-uri/LICENSE @@ -0,0 +1,30 @@ +Copyright (c) 2011-2021, Gary Court until https://github.com/garycourt/uri-js/commit/a1acf730b4bba3f1097c9f52e7d9d3aba8cdcaae +Copyright (c) 2021-present The Fastify team +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * The names of any contributors may not be used to endorse or promote + products derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + * * * + +The complete list of contributors can be found at: +- https://github.com/garycourt/uri-js/graphs/contributors \ No newline at end of file diff --git a/tools/ui/node_modules/fast-uri/README.md b/tools/ui/node_modules/fast-uri/README.md new file mode 100644 index 0000000000000000000000000000000000000000..87ae09545a6480ba223f07fd431c3ede0ffb2e73 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/README.md @@ -0,0 +1,152 @@ +# fast-uri + +[![NPM version](https://img.shields.io/npm/v/fast-uri.svg?style=flat)](https://www.npmjs.com/package/fast-uri) +[![CI](https://github.com/fastify/fast-uri/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/fastify/fast-uri/actions/workflows/ci.yml) +[![neostandard javascript style](https://img.shields.io/badge/code_style-neostandard-brightgreen?style=flat)](https://github.com/neostandard/neostandard) + +Dependency-free RFC 3986 URI toolbox. + +## Usage + +## Options + +All of the above functions can accept an additional options argument that is an object that can contain one or more of the following properties: + +Malformed authorities and out-of-range ports are reported through the parsed component's `error` field. `normalize()` leaves malformed string inputs unchanged, and `equal()` returns `false` when either string input is malformed. + +* `scheme` (string) + Indicates the scheme that the URI should be treated as, overriding the URI's normal scheme parsing behavior. + +* `reference` (string) + If set to `"suffix"`, it indicates that the URI is in the suffix format and the parser will use the option's `scheme` property to determine the URI's scheme. + +* `tolerant` (boolean, false) + If set to `true`, the parser will relax URI resolving rules. + +* `absolutePath` (boolean, false) + If set to `true`, the serializer will not resolve a relative `path` component. + +* `unicodeSupport` (boolean, false) + If set to `true`, the parser will unescape non-ASCII characters in the parsed output as per [RFC 3987](http://www.ietf.org/rfc/rfc3987.txt). + +* `domainHost` (boolean, false) + If set to `true`, the library will treat the `host` component as a domain name, and convert IDNs (International Domain Names) as per [RFC 5891](http://www.ietf.org/rfc/rfc5891.txt). + +### Parse + +```js +const uri = require('fast-uri') +uri.parse('uri://user:pass@example.com:123/one/two.three?q1=a1&q2=a2#body') +// Output +{ + scheme: "uri", + userinfo: "user:pass", + host: "example.com", + port: 123, + path: "/one/two.three", + query: "q1=a1&q2=a2", + fragment: "body" +} +``` + +### Serialize + +```js +const uri = require('fast-uri') +uri.serialize({scheme: "http", host: "example.com", fragment: "footer"}) +// Output +"http://example.com/#footer" + +``` + +### Resolve + +```js +const uri = require('fast-uri') +uri.resolve("uri://a/b/c/d?q", "../../g") +// Output +"uri://a/g" +``` + +### Normalize + +```js +const uri = require('fast-uri') +uri.normalize('http://example.com/a%2Fb') +// Output +"http://example.com/a%2Fb" +``` + +Reserved path escapes such as `%2F` and `%2E` are preserved as path data during normalization and comparison. + +### Equal + +```js +const uri = require('fast-uri') +uri.equal("example://a/b/c/%7Bfoo%7D", "eXAMPLE://a/./b/../b/%63/%7bfoo%7d") +// Output +true +``` + +## Scheme supports + +fast-uri supports inserting custom [scheme](http://en.wikipedia.org/wiki/URI_scheme)-dependent processing rules. Currently, fast-uri has built-in support for the following schemes: + +* http \[[RFC 2616](http://www.ietf.org/rfc/rfc2616.txt)\] +* https \[[RFC 2818](http://www.ietf.org/rfc/rfc2818.txt)\] +* ws \[[RFC 6455](http://www.ietf.org/rfc/rfc6455.txt)\] +* wss \[[RFC 6455](http://www.ietf.org/rfc/rfc6455.txt)\] +* urn \[[RFC 2141](http://www.ietf.org/rfc/rfc2141.txt)\] +* urn:uuid \[[RFC 4122](http://www.ietf.org/rfc/rfc4122.txt)\] + + +## Benchmarks + +``` +fast-uri benchmark +┌─────────┬──────────────────────────────────────────┬──────────────────┬──────────────────┬────────────────────────┬────────────────────────┬─────────┐ +│ (index) │ Task name │ Latency avg (ns) │ Latency med (ns) │ Throughput avg (ops/s) │ Throughput med (ops/s) │ Samples │ +├─────────┼──────────────────────────────────────────┼──────────────────┼──────────────────┼────────────────────────┼────────────────────────┼─────────┤ +│ 0 │ 'fast-uri: parse domain' │ '951.31 ± 0.75%' │ '875.00 ± 11.00' │ '1122538 ± 0.01%' │ '1142857 ± 14550' │ 1051187 │ +│ 1 │ 'fast-uri: parse IPv4' │ '443.44 ± 0.22%' │ '406.00 ± 3.00' │ '2422762 ± 0.01%' │ '2463054 ± 18335' │ 2255105 │ +│ 2 │ 'fast-uri: parse IPv6' │ '1241.6 ± 1.74%' │ '1131.0 ± 30.00' │ '875177 ± 0.02%' │ '884173 ± 24092' │ 805399 │ +│ 3 │ 'fast-uri: parse URN' │ '689.19 ± 4.29%' │ '618.00 ± 9.00' │ '1598373 ± 0.01%' │ '1618123 ± 23913' │ 1450972 │ +│ 4 │ 'fast-uri: parse URN uuid' │ '1025.4 ± 2.02%' │ '921.00 ± 19.00' │ '1072419 ± 0.02%' │ '1085776 ± 22871' │ 975236 │ +│ 5 │ 'fast-uri: serialize uri' │ '1028.5 ± 0.53%' │ '933.00 ± 43.00' │ '1063310 ± 0.02%' │ '1071811 ± 50523' │ 972249 │ +│ 6 │ 'fast-uri: serialize long uri with dots' │ '1805.1 ± 0.52%' │ '1627.0 ± 17.00' │ '602620 ± 0.02%' │ '614628 ± 6490' │ 553997 │ +│ 7 │ 'fast-uri: serialize IPv6' │ '2569.4 ± 2.69%' │ '2302.0 ± 21.00' │ '426080 ± 0.03%' │ '434405 ± 3999' │ 389194 │ +│ 8 │ 'fast-uri: serialize ws' │ '979.39 ± 0.43%' │ '882.00 ± 8.00' │ '1111665 ± 0.02%' │ '1133787 ± 10378' │ 1021045 │ +│ 9 │ 'fast-uri: resolve' │ '2208.2 ± 1.08%' │ '1980.0 ± 24.00' │ '495001 ± 0.03%' │ '505051 ± 6049' │ 452848 │ +└─────────┴──────────────────────────────────────────┴──────────────────┴──────────────────┴────────────────────────┴────────────────────────┴─────────┘ +uri-js benchmark +┌─────────┬───────────────────────────────────────┬──────────────────┬──────────────────┬────────────────────────┬────────────────────────┬─────────┐ +│ (index) │ Task name │ Latency avg (ns) │ Latency med (ns) │ Throughput avg (ops/s) │ Throughput med (ops/s) │ Samples │ +├─────────┼───────────────────────────────────────┼──────────────────┼──────────────────┼────────────────────────┼────────────────────────┼─────────┤ +│ 0 │ 'urijs: parse domain' │ '3618.3 ± 0.43%' │ '3314.0 ± 33.00' │ '294875 ± 0.04%' │ '301750 ± 2975' │ 276375 │ +│ 1 │ 'urijs: parse IPv4' │ '4024.1 ± 0.41%' │ '3751.0 ± 25.00' │ '261981 ± 0.04%' │ '266596 ± 1789' │ 248506 │ +│ 2 │ 'urijs: parse IPv6' │ '5417.2 ± 0.46%' │ '4968.0 ± 43.00' │ '196023 ± 0.05%' │ '201288 ± 1727' │ 184598 │ +│ 3 │ 'urijs: parse URN' │ '1324.2 ± 0.23%' │ '1229.0 ± 17.00' │ '801535 ± 0.02%' │ '813670 ± 11413' │ 755185 │ +│ 4 │ 'urijs: parse URN uuid' │ '1822.0 ± 3.08%' │ '1655.0 ± 15.00' │ '594433 ± 0.02%' │ '604230 ± 5427' │ 548843 │ +│ 5 │ 'urijs: serialize uri' │ '4196.8 ± 0.36%' │ '3908.0 ± 27.00' │ '251146 ± 0.04%' │ '255885 ± 1756' │ 238276 │ +│ 6 │ 'urijs: serialize long uri with dots' │ '8331.0 ± 1.30%' │ '7658.0 ± 72.00' │ '126440 ± 0.07%' │ '130582 ± 1239' │ 120034 │ +│ 7 │ 'urijs: serialize IPv6' │ '5685.5 ± 0.30%' │ '5366.0 ± 33.00' │ '182632 ± 0.05%' │ '186359 ± 1153' │ 175886 │ +│ 8 │ 'urijs: serialize ws' │ '4159.3 ± 0.20%' │ '3899.0 ± 28.00' │ '250459 ± 0.04%' │ '256476 ± 1855' │ 240423 │ +│ 9 │ 'urijs: resolve' │ '6729.9 ± 0.39%' │ '6261.0 ± 37.00' │ '156361 ± 0.06%' │ '159719 ± 949' │ 148591 │ +└─────────┴───────────────────────────────────────┴──────────────────┴──────────────────┴────────────────────────┴────────────────────────┴─────────┘ +WHATWG URL benchmark +┌─────────┬────────────────────────────┬──────────────────┬──────────────────┬────────────────────────┬────────────────────────┬─────────┐ +│ (index) │ Task name │ Latency avg (ns) │ Latency med (ns) │ Throughput avg (ops/s) │ Throughput med (ops/s) │ Samples │ +├─────────┼────────────────────────────┼──────────────────┼──────────────────┼────────────────────────┼────────────────────────┼─────────┤ +│ 0 │ 'WHATWG URL: parse domain' │ '475.22 ± 0.20%' │ '444.00 ± 5.00' │ '2217599 ± 0.01%' │ '2252252 ± 25652' │ 2104289 │ +│ 1 │ 'WHATWG URL: parse URN' │ '384.78 ± 0.85%' │ '350.00 ± 5.00' │ '2809071 ± 0.01%' │ '2857143 ± 41408' │ 2598885 │ +└─────────┴────────────────────────────┴──────────────────┴──────────────────┴────────────────────────┴────────────────────────┴─────────┘ +``` + +## TODO + +- [ ] Support MailTo +- [ ] Be 100% iso compatible with uri-js + +## License + +Licensed under [BSD-3-Clause](./LICENSE). diff --git a/tools/ui/node_modules/fast-uri/benchmark/benchmark.mjs b/tools/ui/node_modules/fast-uri/benchmark/benchmark.mjs new file mode 100644 index 0000000000000000000000000000000000000000..2e49fc678343e81a563a4f31779a06dd585f8283 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/benchmark/benchmark.mjs @@ -0,0 +1,159 @@ +import { Bench } from 'tinybench' +import { fastUri } from '../index.js' +import { parse as uriJsParse, serialize as uriJsSerialize, resolve as uriJsResolve, equal as uriJsEqual } from 'uri-js' + +const base = 'uri://a/b/c/d;p?q' + +const domain = 'https://example.com/foo#bar$fiz' +const ipv4 = '//10.10.10.10' +const ipv6 = '//[2001:db8::7]' +const urn = 'urn:foo:a123,456' +const urnuuid = 'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6' + +const urnuuidComponent = { + scheme: 'urn', + nid: 'uuid', + uuid: 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6' +} + +const { + parse: fastUriParse, + serialize: fastUriSerialize, + resolve: fastUriResolve, + equal: fastUriEqual, +} = fastUri + +// Initialization as there is a lot to parse at first +// eg: regexes +fastUriParse(domain) +uriJsParse(domain) + +const benchFastUri = new Bench({ name: 'fast-uri benchmark' }) +const benchUriJs = new Bench({ name: 'uri-js benchmark' }) +const benchWHATWG = new Bench({ name: 'WHATWG URL benchmark' }) + +benchFastUri.add('fast-uri: parse domain', function () { + fastUriParse(domain) +}) +benchUriJs.add('urijs: parse domain', function () { + uriJsParse(domain) +}) +benchWHATWG.add('WHATWG URL: parse domain', function () { + // eslint-disable-next-line + new URL(domain) +}) +benchFastUri.add('fast-uri: parse IPv4', function () { + fastUriParse(ipv4) +}) +benchUriJs.add('urijs: parse IPv4', function () { + uriJsParse(ipv4) +}) +benchFastUri.add('fast-uri: parse IPv6', function () { + fastUriParse(ipv6) +}) +benchUriJs.add('urijs: parse IPv6', function () { + uriJsParse(ipv6) +}) +benchFastUri.add('fast-uri: parse URN', function () { + fastUriParse(urn) +}) +benchUriJs.add('urijs: parse URN', function () { + uriJsParse(urn) +}) +benchWHATWG.add('WHATWG URL: parse URN', function () { + // eslint-disable-next-line + new URL(urn) +}) +benchFastUri.add('fast-uri: parse URN uuid', function () { + fastUriParse(urnuuid) +}) +benchUriJs.add('urijs: parse URN uuid', function () { + uriJsParse(urnuuid) +}) +benchFastUri.add('fast-uri: serialize URN uuid', function () { + fastUriSerialize(urnuuidComponent) +}) +benchUriJs.add('uri-js: serialize URN uuid', function () { + uriJsSerialize(urnuuidComponent) +}) +benchFastUri.add('fast-uri: serialize uri', function () { + fastUriSerialize({ + scheme: 'uri', + userinfo: 'foo:bar', + host: 'example.com', + port: 1, + path: 'path', + query: 'query', + fragment: 'fragment' + }) +}) +benchUriJs.add('urijs: serialize uri', function () { + uriJsSerialize({ + scheme: 'uri', + userinfo: 'foo:bar', + host: 'example.com', + port: 1, + path: 'path', + query: 'query', + fragment: 'fragment' + }) +}) +benchFastUri.add('fast-uri: serialize long uri with dots', function () { + fastUriSerialize({ + scheme: 'uri', + userinfo: 'foo:bar', + host: 'example.com', + port: 1, + path: './a/./b/c/../.././d/../e/f/.././/', + query: 'query', + fragment: 'fragment' + }) +}) +benchUriJs.add('urijs: serialize long uri with dots', function () { + uriJsSerialize({ + scheme: 'uri', + userinfo: 'foo:bar', + host: 'example.com', + port: 1, + path: './a/./b/c/../.././d/../e/f/.././/', + query: 'query', + fragment: 'fragment' + }) +}) +benchFastUri.add('fast-uri: serialize IPv6', function () { + fastUriSerialize({ host: '2606:2800:220:1:248:1893:25c8:1946' }) +}) +benchUriJs.add('urijs: serialize IPv6', function () { + uriJsSerialize({ host: '2606:2800:220:1:248:1893:25c8:1946' }) +}) +benchFastUri.add('fast-uri: serialize ws', function () { + fastUriSerialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: true }) +}) +benchUriJs.add('urijs: serialize ws', function () { + uriJsSerialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: true }) +}) +benchFastUri.add('fast-uri: resolve', function () { + fastUriResolve(base, '../../../g') +}) +benchUriJs.add('urijs: resolve', function () { + uriJsResolve(base, '../../../g') +}) + +benchFastUri.add('fast-uri: equal', function () { + fastUriEqual('example://a/b/c/%7Bfoo%7D', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d') +}) +benchUriJs.add('urijs: equal', function () { + uriJsEqual('example://a/b/c/%7Bfoo%7D', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d') +}) + +await benchFastUri.run() +console.log(benchFastUri.name) +console.table(benchFastUri.table()) + +await benchUriJs.run() +console.log(benchUriJs.name) +console.table(benchUriJs.table()) + +await benchWHATWG.run() +console.log(benchWHATWG.name) +console.table(benchWHATWG.table()) diff --git a/tools/ui/node_modules/fast-uri/benchmark/equal.mjs b/tools/ui/node_modules/fast-uri/benchmark/equal.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3dea7ec8762a87635475adbea09ee54751285e13 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/benchmark/equal.mjs @@ -0,0 +1,51 @@ +import { Bench } from 'tinybench' +import { fastUri } from '../index.js' + +const { + equal: fastUriEqual, + parse: fastUriParse, +} = fastUri + +const stringA = 'example://a/b/c/%7Bfoo%7D' +const stringB = 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d' + +const componentA = fastUriParse(stringA) +const componentB = fastUriParse(stringB) + +const benchFastUri = new Bench({ name: 'fast-uri equal' }) + +benchFastUri.add('equal string with string', function () { + fastUriEqual(stringA, stringA) +}) + +benchFastUri.add('equal component with component', function () { + fastUriEqual(componentA, componentA) +}) + +benchFastUri.add('equal component with string', function () { + fastUriEqual(componentA, stringA) +}) + +benchFastUri.add('equal string with component', function () { + fastUriEqual(stringA, componentA) +}) + +benchFastUri.add('not equal string with string', function () { + fastUriEqual(stringA, stringB) +}) + +benchFastUri.add('not equal component with component', function () { + fastUriEqual(componentA, componentB) +}) + +benchFastUri.add('not equal component with string', function () { + fastUriEqual(componentA, stringB) +}) + +benchFastUri.add('not equal string with component', function () { + fastUriEqual(stringA, componentB) +}) + +await benchFastUri.run() +console.log(benchFastUri.name) +console.table(benchFastUri.table()) diff --git a/tools/ui/node_modules/fast-uri/benchmark/non-simple-domain.mjs b/tools/ui/node_modules/fast-uri/benchmark/non-simple-domain.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4c041da4cd3f3fd5182ccc9f11c6ec08f42003d6 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/benchmark/non-simple-domain.mjs @@ -0,0 +1,22 @@ +import { Bench } from 'tinybench' +import { nonSimpleDomain } from '../lib/utils.js' + +const benchNonSimpleDomain = new Bench({ name: 'nonSimpleDomain' }) + +const exampleCom = 'example.com' +const exaumlmpleCom = 'exämple.com' +const longDomain = 'abc'.repeat(100) + '.com' + +console.assert(nonSimpleDomain(exampleCom) === false, 'example.com should be a simple domain') +console.assert(nonSimpleDomain(exaumlmpleCom) === true, 'exämple.com should not be a simple domain') +console.assert(nonSimpleDomain(longDomain) === false, `${longDomain} should be a simple domain?`) + +benchNonSimpleDomain.add('nonSimpleDomain', function () { + nonSimpleDomain(exampleCom) + nonSimpleDomain(exaumlmpleCom) + nonSimpleDomain(longDomain) +}) + +await benchNonSimpleDomain.run() +console.log(benchNonSimpleDomain.name) +console.table(benchNonSimpleDomain.table()) diff --git a/tools/ui/node_modules/fast-uri/benchmark/package.json b/tools/ui/node_modules/fast-uri/benchmark/package.json new file mode 100644 index 0000000000000000000000000000000000000000..7c0816a57919a8dcf1769563de87543218926d29 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/benchmark/package.json @@ -0,0 +1,17 @@ +{ + "name": "benchmark", + "version": "1.0.0", + "description": "", + "main": "index.js", + "private": true, + "scripts": { + "bench": "node benchmark.mjs" + }, + "keywords": [], + "author": "", + "license": "ISC", + "dependencies": { + "tinybench": "^5.0.0", + "uri-js": "^4.4.1" + } +} diff --git a/tools/ui/node_modules/fast-uri/benchmark/string-array-to-hex-stripped.mjs b/tools/ui/node_modules/fast-uri/benchmark/string-array-to-hex-stripped.mjs new file mode 100644 index 0000000000000000000000000000000000000000..94875dade99a069e0cbc60267b412a8d53dd2bf9 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/benchmark/string-array-to-hex-stripped.mjs @@ -0,0 +1,24 @@ +import { Bench } from 'tinybench' +import { stringArrayToHexStripped } from '../lib/utils.js' + +const benchStringArrayToHexStripped = new Bench({ name: 'stringArrayToHexStripped' }) + +const case1 = ['0', '0', '0', '0'] +const case2 = ['0', '0', '0', '1'] +const case3 = ['0', '0', '1', '0'] +const case4 = ['0', '1', '0', '0'] +const case5 = ['1', '0', '0', '0'] +const case6 = ['1', '0', '0', '1'] + +benchStringArrayToHexStripped.add('stringArrayToHexStripped', function () { + stringArrayToHexStripped(case1) + stringArrayToHexStripped(case2) + stringArrayToHexStripped(case3) + stringArrayToHexStripped(case4) + stringArrayToHexStripped(case5) + stringArrayToHexStripped(case6) +}) + +await benchStringArrayToHexStripped.run() +console.log(benchStringArrayToHexStripped.name) +console.table(benchStringArrayToHexStripped.table()) diff --git a/tools/ui/node_modules/fast-uri/benchmark/ws-is-secure.mjs b/tools/ui/node_modules/fast-uri/benchmark/ws-is-secure.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b579a7662170f8dfefb595f162620d5c5bf31f03 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/benchmark/ws-is-secure.mjs @@ -0,0 +1,65 @@ +import { Bench } from 'tinybench' +import { wsIsSecure } from '../lib/schemes.js' + +const benchWsIsSecure = new Bench({ name: 'wsIsSecure' }) + +const wsComponentAttributeSecureTrue = { + scheme: 'ws', + secure: true, +} + +const wsComponentAttributeSecureFalse = { + scheme: 'ws', + secure: false, +} + +const wssComponent = { + scheme: 'wss', +} + +const wssComponentMixedCase = { + scheme: 'Wss', +} + +const wssComponentUpperCase = { + scheme: 'WSS', +} + +const httpComponent = { + scheme: 'http', +} + +console.assert(wsIsSecure(wsComponentAttributeSecureTrue) === true, 'wsComponentAttributeSecureTrue should be secure') +console.assert(wsIsSecure(wsComponentAttributeSecureFalse) === false, 'wsComponentAttributeSecureFalse should not be secure') +console.assert(wsIsSecure(wssComponent) === true, 'wssComponent should be secure') +console.assert(wsIsSecure(wssComponentMixedCase) === true, 'wssComponentMixedCase should be secure') +console.assert(wsIsSecure(wssComponentUpperCase) === true, 'wssComponentUpperCase should be secure') +console.assert(wsIsSecure(httpComponent) === false, 'httpComponent should not be secure') + +benchWsIsSecure.add(JSON.stringify(wsComponentAttributeSecureFalse), function () { + wsIsSecure(wsComponentAttributeSecureFalse) +}) + +benchWsIsSecure.add(JSON.stringify(wsComponentAttributeSecureTrue), function () { + wsIsSecure(wsComponentAttributeSecureTrue) +}) + +benchWsIsSecure.add(JSON.stringify(wssComponent), function () { + wsIsSecure(wssComponent) +}) + +benchWsIsSecure.add(JSON.stringify(wssComponentMixedCase), function () { + wsIsSecure(wssComponentMixedCase) +}) + +benchWsIsSecure.add(JSON.stringify(wssComponentUpperCase), function () { + wsIsSecure(wssComponentUpperCase) +}) + +benchWsIsSecure.add(JSON.stringify(httpComponent), function () { + wsIsSecure(httpComponent) +}) + +await benchWsIsSecure.run() +console.log(benchWsIsSecure.name) +console.table(benchWsIsSecure.table()) diff --git a/tools/ui/node_modules/fast-uri/eslint.config.js b/tools/ui/node_modules/fast-uri/eslint.config.js new file mode 100644 index 0000000000000000000000000000000000000000..89fd678fe2a82d7fe3be869fffd71b3631c61c6a --- /dev/null +++ b/tools/ui/node_modules/fast-uri/eslint.config.js @@ -0,0 +1,6 @@ +'use strict' + +module.exports = require('neostandard')({ + ignores: require('neostandard').resolveIgnoresFromGitignore(), + ts: true +}) diff --git a/tools/ui/node_modules/fast-uri/index.js b/tools/ui/node_modules/fast-uri/index.js new file mode 100644 index 0000000000000000000000000000000000000000..fd8ad70cc6b50057c69a226b7062743c9c7f6b17 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/index.js @@ -0,0 +1,459 @@ +'use strict' + +const { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require('./lib/utils') +const { SCHEMES, getSchemeHandler } = require('./lib/schemes') + +/** + * @template {import('./types/index').URIComponent|string} T + * @param {T} uri + * @param {import('./types/index').Options} [options] + * @returns {T} + */ +function normalize (uri, options) { + if (typeof uri === 'string') { + uri = /** @type {T} */ (normalizeString(uri, options)) + } else if (typeof uri === 'object') { + uri = /** @type {T} */ (parse(serialize(uri, options), options)) + } + return uri +} + +/** + * @param {string} baseURI + * @param {string} relativeURI + * @param {import('./types/index').Options} [options] + * @returns {string} + */ +function resolve (baseURI, relativeURI, options) { + const schemelessOptions = options ? Object.assign({ scheme: 'null' }, options) : { scheme: 'null' } + const { parsed: baseParsed, malformedAuthorityOrPort: baseMalformed } = parseWithStatus(baseURI, schemelessOptions) + const { parsed: relativeParsed, malformedAuthorityOrPort: relativeMalformed } = parseWithStatus(relativeURI, schemelessOptions) + if (baseMalformed || relativeMalformed) { + throw new Error(baseParsed.error || relativeParsed.error || 'URI is malformed.') + } + const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true) + schemelessOptions.skipEscape = true + return serialize(resolved, schemelessOptions) +} + +/** + * @param {import ('./types/index').URIComponent} base + * @param {import ('./types/index').URIComponent} relative + * @param {import('./types/index').Options} [options] + * @param {boolean} [skipNormalization=false] + * @returns {import ('./types/index').URIComponent} + */ +function resolveComponent (base, relative, options, skipNormalization) { + /** @type {import('./types/index').URIComponent} */ + const target = {} + if (!skipNormalization) { + base = parse(serialize(base, options), options) // normalize base component + relative = parse(serialize(relative, options), options) // normalize relative component + } + options = options || {} + + if (!options.tolerant && relative.scheme) { + target.scheme = relative.scheme + // target.authority = relative.authority; + target.userinfo = relative.userinfo + target.host = relative.host + target.port = relative.port + target.path = removeDotSegments(relative.path || '') + target.query = relative.query + } else { + if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) { + // target.authority = relative.authority; + target.userinfo = relative.userinfo + target.host = relative.host + target.port = relative.port + target.path = removeDotSegments(relative.path || '') + target.query = relative.query + } else { + if (!relative.path) { + target.path = base.path + if (relative.query !== undefined) { + target.query = relative.query + } else { + target.query = base.query + } + } else { + if (relative.path[0] === '/') { + target.path = removeDotSegments(relative.path) + } else { + if ((base.userinfo !== undefined || base.host !== undefined || base.port !== undefined) && !base.path) { + target.path = '/' + relative.path + } else if (!base.path) { + target.path = relative.path + } else { + target.path = base.path.slice(0, base.path.lastIndexOf('/') + 1) + relative.path + } + target.path = removeDotSegments(target.path) + } + target.query = relative.query + } + // target.authority = base.authority; + target.userinfo = base.userinfo + target.host = base.host + target.port = base.port + } + target.scheme = base.scheme + } + + target.fragment = relative.fragment + + return target +} + +/** + * @param {import ('./types/index').URIComponent|string} uriA + * @param {import ('./types/index').URIComponent|string} uriB + * @param {import ('./types/index').Options} options + * @returns {boolean} + */ +function equal (uriA, uriB, options) { + const normalizedA = normalizeComparableURI(uriA, options) + const normalizedB = normalizeComparableURI(uriB, options) + + return normalizedA !== undefined && normalizedB !== undefined && normalizedA.toLowerCase() === normalizedB.toLowerCase() +} + +/** + * @param {Readonly} cmpts + * @param {import('./types/index').Options} [opts] + * @returns {string} + */ +function serialize (cmpts, opts) { + const component = { + host: cmpts.host, + scheme: cmpts.scheme, + userinfo: cmpts.userinfo, + port: cmpts.port, + path: cmpts.path, + query: cmpts.query, + nid: cmpts.nid, + nss: cmpts.nss, + uuid: cmpts.uuid, + fragment: cmpts.fragment, + reference: cmpts.reference, + resourceName: cmpts.resourceName, + secure: cmpts.secure, + error: '' + } + const options = Object.assign({}, opts) + const uriTokens = [] + + // find scheme handler + const schemeHandler = getSchemeHandler(options.scheme || component.scheme) + + // perform scheme specific serialization + if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options) + + if (component.path !== undefined) { + if (!options.skipEscape) { + component.path = escapePreservingEscapes(component.path) + + if (component.scheme !== undefined) { + component.path = component.path.split('%3A').join(':') + } + } else { + component.path = normalizePercentEncoding(component.path) + } + } + + if (options.reference !== 'suffix' && component.scheme) { + uriTokens.push(component.scheme, ':') + } + + const authority = recomposeAuthority(component) + if (authority !== undefined) { + if (options.reference !== 'suffix') { + uriTokens.push('//') + } + + uriTokens.push(authority) + + if (component.path && component.path[0] !== '/') { + uriTokens.push('/') + } + } + if (component.path !== undefined) { + let s = component.path + + if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) { + s = removeDotSegments(s) + } + + if ( + authority === undefined && + s[0] === '/' && + s[1] === '/' + ) { + // don't allow the path to start with "//" + s = '/%2F' + s.slice(2) + } + + uriTokens.push(s) + } + + if (component.query !== undefined) { + uriTokens.push('?', component.query) + } + + if (component.fragment !== undefined) { + uriTokens.push('#', component.fragment) + } + return uriTokens.join('') +} + +const URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u + +// Captures the authority component (between "//" and the next "/", "?" or "#"), +// with or without a scheme prefix, for the literal-backslash rejection below. +const AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/ + +// Captures the leading authority-introducer region after an optional scheme: a +// run of forward slashes, backslashes, and the characters the WHATWG URL parser +// removes before parsing (TAB U+0009, LF U+000A, CR U+000D). A valid introducer +// is exactly "//". Node treats "\" as "/" on special schemes and strips those +// characters first, so forms like "\\", "/\", "\/", "//", or a leading +// "//" reach an authority in Node while fast-uri's URI_PARSE folds them into +// the path group (host confusion / SSRF / redirect bypass). +const AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/ + +/** + * @param {import('./types/index').URIComponent} parsed + * @param {RegExpMatchArray} matches + * @returns {string|undefined} + */ +function getParseError (parsed, matches) { + if (matches[2] !== undefined && parsed.path && parsed.path[0] !== '/') { + return 'URI path must start with "/" when authority is present.' + } + + if (typeof parsed.port === 'number' && (parsed.port < 0 || parsed.port > 65535)) { + return 'URI port is malformed.' + } + + return undefined +} + +/** + * @param {string} uri + * @param {import('./types/index').Options} [opts] + * @returns {{ parsed: import('./types/index').URIComponent, malformedAuthorityOrPort: boolean }} + */ +function parseWithStatus (uri, opts) { + const options = Object.assign({}, opts) + /** @type {import('./types/index').URIComponent} */ + const parsed = { + scheme: undefined, + userinfo: undefined, + host: '', + port: undefined, + path: '', + query: undefined, + fragment: undefined + } + + let malformedAuthorityOrPort = false + + let isIP = false + if (options.reference === 'suffix') { + if (options.scheme) { + uri = options.scheme + ':' + uri + } else { + uri = '//' + uri + } + } + + // A literal backslash (U+005C) is not a valid RFC 3986 URI character and is + // not an authority delimiter. Reject it in the authority rather than + // rewriting it: normalizing "\" -> "/" (WHATWG error recovery) could silently + // change the resource identified by an otherwise-invalid input, and lets "\" + // act as a host delimiter here while Node's native URL parses a different + // host (SSRF / redirect / origin-allowlist bypass). Percent-encoded %5C is + // untouched and remains valid encoded data. + const authorityMatch = uri.match(AUTHORITY_PREFIX) + if (authorityMatch !== null && authorityMatch[1].indexOf('\\') !== -1) { + parsed.error = 'URI authority must not contain a literal backslash.' + malformedAuthorityOrPort = true + } + + // Reject a malformed or whitespace-smuggled authority introducer. fast-uri + // only recognizes a literal "//"; anything else in the leading separator run + // (a backslash, or a "//" that appears only after removing the TAB/LF/CR that + // Node strips) means the authority fast-uri parses differs from the one Node's + // URL resolves. Reject rather than rewrite, mirroring the literal-backslash + // guard above. Percent-encoded forms (%5C, %09) are untouched, valid data. + const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION) + if (introducerMatch !== null) { + const region = introducerMatch[1] + const normalizedRegion = region.replace(/[\t\n\r]/g, '') + // Two or more leading separators introduce an authority. + if (normalizedRegion.length >= 2) { + if (normalizedRegion.slice(0, 2) !== '//') { + parsed.error = parsed.error || 'URI authority must not contain a literal backslash.' + malformedAuthorityOrPort = true + } else if (region.length !== normalizedRegion.length) { + parsed.error = parsed.error || 'URI authority introducer must not contain whitespace.' + malformedAuthorityOrPort = true + } + } + } + + const matches = uri.match(URI_PARSE) + + if (matches) { + // store each component + parsed.scheme = matches[1] + parsed.userinfo = matches[3] + parsed.host = matches[4] + parsed.port = parseInt(matches[5], 10) + parsed.path = matches[6] || '' + parsed.query = matches[7] + parsed.fragment = matches[8] + + // fix port number + if (isNaN(parsed.port)) { + parsed.port = matches[5] + } + + const parseError = getParseError(parsed, matches) + if (parseError !== undefined) { + parsed.error = parsed.error || parseError + malformedAuthorityOrPort = true + } + + if (parsed.host) { + const ipv4result = isIPv4(parsed.host) + if (ipv4result === false) { + const ipv6result = normalizeIPv6(parsed.host) + parsed.host = ipv6result.host.toLowerCase() + isIP = ipv6result.isIPV6 + } else { + isIP = true + } + } + if (parsed.scheme === undefined && parsed.userinfo === undefined && parsed.host === undefined && parsed.port === undefined && parsed.query === undefined && !parsed.path) { + parsed.reference = 'same-document' + } else if (parsed.scheme === undefined) { + parsed.reference = 'relative' + } else if (parsed.fragment === undefined) { + parsed.reference = 'absolute' + } else { + parsed.reference = 'uri' + } + + // check for reference errors + if (options.reference && options.reference !== 'suffix' && options.reference !== parsed.reference) { + parsed.error = parsed.error || 'URI is not a ' + options.reference + ' reference.' + } + + // find scheme handler + const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme) + + // check if scheme can't handle IRIs + if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) { + // if host component is a domain name + if (parsed.host && (options.domainHost || (schemeHandler && schemeHandler.domainHost)) && isIP === false && nonSimpleDomain(parsed.host)) { + // convert Unicode IDN -> ASCII IDN + try { + parsed.host = new URL('http://' + parsed.host).hostname + } catch (e) { + parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e + } + } + // convert IRI -> URI + } + + if (!schemeHandler || (schemeHandler && !schemeHandler.skipNormalize)) { + if (uri.indexOf('%') !== -1) { + if (parsed.scheme !== undefined) { + parsed.scheme = unescape(parsed.scheme) + } + if (parsed.host !== undefined) { + parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP) + } + } + if (parsed.path) { + parsed.path = normalizePathEncoding(parsed.path) + } + if (parsed.fragment) { + try { + parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment)) + } catch { + parsed.error = parsed.error || 'URI malformed' + } + } + } + + // perform scheme specific parsing + if (schemeHandler && schemeHandler.parse) { + schemeHandler.parse(parsed, options) + } + } else { + parsed.error = parsed.error || 'URI can not be parsed.' + } + return { parsed, malformedAuthorityOrPort } +} + +/** + * @param {string} uri + * @param {import('./types/index').Options} [opts] + * @returns + */ +function parse (uri, opts) { + return parseWithStatus(uri, opts).parsed +} + +/** + * @param {string} uri + * @param {import('./types/index').Options} [opts] + * @returns {string} + */ +function normalizeString (uri, opts) { + return normalizeStringWithStatus(uri, opts).normalized +} + +/** + * @param {string} uri + * @param {import('./types/index').Options} [opts] + * @returns {{ normalized: string, malformedAuthorityOrPort: boolean }} + */ +function normalizeStringWithStatus (uri, opts) { + const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts) + return { + normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts), + malformedAuthorityOrPort + } +} + +/** + * @param {import ('./types/index').URIComponent|string} uri + * @param {import('./types/index').Options} [opts] + * @returns {string|undefined} + */ +function normalizeComparableURI (uri, opts) { + if (typeof uri === 'string') { + const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts) + return malformedAuthorityOrPort ? undefined : normalized + } + + if (typeof uri === 'object') { + return serialize(uri, opts) + } +} + +const fastUri = { + SCHEMES, + normalize, + resolve, + resolveComponent, + equal, + serialize, + parse +} + +module.exports = fastUri +module.exports.default = fastUri +module.exports.fastUri = fastUri diff --git a/tools/ui/node_modules/fast-uri/lib/schemes.js b/tools/ui/node_modules/fast-uri/lib/schemes.js new file mode 100644 index 0000000000000000000000000000000000000000..554e379911e39ce4df7babc647b588419312649b --- /dev/null +++ b/tools/ui/node_modules/fast-uri/lib/schemes.js @@ -0,0 +1,267 @@ +'use strict' + +const { isUUID } = require('./utils') +const URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu + +const supportedSchemeNames = /** @type {const} */ (['http', 'https', 'ws', + 'wss', 'urn', 'urn:uuid']) + +/** @typedef {supportedSchemeNames[number]} SchemeName */ + +/** + * @param {string} name + * @returns {name is SchemeName} + */ +function isValidSchemeName (name) { + return supportedSchemeNames.indexOf(/** @type {*} */ (name)) !== -1 +} + +/** + * @callback SchemeFn + * @param {import('../types/index').URIComponent} component + * @param {import('../types/index').Options} options + * @returns {import('../types/index').URIComponent} + */ + +/** + * @typedef {Object} SchemeHandler + * @property {SchemeName} scheme - The scheme name. + * @property {boolean} [domainHost] - Indicates if the scheme supports domain hosts. + * @property {SchemeFn} parse - Function to parse the URI component for this scheme. + * @property {SchemeFn} serialize - Function to serialize the URI component for this scheme. + * @property {boolean} [skipNormalize] - Indicates if normalization should be skipped for this scheme. + * @property {boolean} [absolutePath] - Indicates if the scheme uses absolute paths. + * @property {boolean} [unicodeSupport] - Indicates if the scheme supports Unicode. + */ + +/** + * @param {import('../types/index').URIComponent} wsComponent + * @returns {boolean} + */ +function wsIsSecure (wsComponent) { + if (wsComponent.secure === true) { + return true + } else if (wsComponent.secure === false) { + return false + } else if (wsComponent.scheme) { + return ( + wsComponent.scheme.length === 3 && + (wsComponent.scheme[0] === 'w' || wsComponent.scheme[0] === 'W') && + (wsComponent.scheme[1] === 's' || wsComponent.scheme[1] === 'S') && + (wsComponent.scheme[2] === 's' || wsComponent.scheme[2] === 'S') + ) + } else { + return false + } +} + +/** @type {SchemeFn} */ +function httpParse (component) { + if (!component.host) { + component.error = component.error || 'HTTP URIs must have a host.' + } + + return component +} + +/** @type {SchemeFn} */ +function httpSerialize (component) { + const secure = String(component.scheme).toLowerCase() === 'https' + + // normalize the default port + if (component.port === (secure ? 443 : 80) || component.port === '') { + component.port = undefined + } + + // normalize the empty path + if (!component.path) { + component.path = '/' + } + + // NOTE: We do not parse query strings for HTTP URIs + // as WWW Form Url Encoded query strings are part of the HTML4+ spec, + // and not the HTTP spec. + + return component +} + +/** @type {SchemeFn} */ +function wsParse (wsComponent) { +// indicate if the secure flag is set + wsComponent.secure = wsIsSecure(wsComponent) + + // construct resouce name + wsComponent.resourceName = (wsComponent.path || '/') + (wsComponent.query ? '?' + wsComponent.query : '') + wsComponent.path = undefined + wsComponent.query = undefined + + return wsComponent +} + +/** @type {SchemeFn} */ +function wsSerialize (wsComponent) { +// normalize the default port + if (wsComponent.port === (wsIsSecure(wsComponent) ? 443 : 80) || wsComponent.port === '') { + wsComponent.port = undefined + } + + // ensure scheme matches secure flag + if (typeof wsComponent.secure === 'boolean') { + wsComponent.scheme = (wsComponent.secure ? 'wss' : 'ws') + wsComponent.secure = undefined + } + + // reconstruct path from resource name + if (wsComponent.resourceName) { + const [path, query] = wsComponent.resourceName.split('?') + wsComponent.path = (path && path !== '/' ? path : undefined) + wsComponent.query = query + wsComponent.resourceName = undefined + } + + // forbid fragment component + wsComponent.fragment = undefined + + return wsComponent +} + +/** @type {SchemeFn} */ +function urnParse (urnComponent, options) { + if (!urnComponent.path) { + urnComponent.error = 'URN can not be parsed' + return urnComponent + } + const matches = urnComponent.path.match(URN_REG) + if (matches) { + const scheme = options.scheme || urnComponent.scheme || 'urn' + urnComponent.nid = matches[1].toLowerCase() + urnComponent.nss = matches[2] + const urnScheme = `${scheme}:${options.nid || urnComponent.nid}` + const schemeHandler = getSchemeHandler(urnScheme) + urnComponent.path = undefined + + if (schemeHandler) { + urnComponent = schemeHandler.parse(urnComponent, options) + } + } else { + urnComponent.error = urnComponent.error || 'URN can not be parsed.' + } + + return urnComponent +} + +/** @type {SchemeFn} */ +function urnSerialize (urnComponent, options) { + if (urnComponent.nid === undefined) { + throw new Error('URN without nid cannot be serialized') + } + const scheme = options.scheme || urnComponent.scheme || 'urn' + const nid = urnComponent.nid.toLowerCase() + const urnScheme = `${scheme}:${options.nid || nid}` + const schemeHandler = getSchemeHandler(urnScheme) + + if (schemeHandler) { + urnComponent = schemeHandler.serialize(urnComponent, options) + } + + const uriComponent = urnComponent + const nss = urnComponent.nss + uriComponent.path = `${nid || options.nid}:${nss}` + + options.skipEscape = true + return uriComponent +} + +/** @type {SchemeFn} */ +function urnuuidParse (urnComponent, options) { + const uuidComponent = urnComponent + uuidComponent.uuid = uuidComponent.nss + uuidComponent.nss = undefined + + if (!options.tolerant && (!uuidComponent.uuid || !isUUID(uuidComponent.uuid))) { + uuidComponent.error = uuidComponent.error || 'UUID is not valid.' + } + + return uuidComponent +} + +/** @type {SchemeFn} */ +function urnuuidSerialize (uuidComponent) { + const urnComponent = uuidComponent + // normalize UUID + urnComponent.nss = (uuidComponent.uuid || '').toLowerCase() + return urnComponent +} + +const http = /** @type {SchemeHandler} */ ({ + scheme: 'http', + domainHost: true, + parse: httpParse, + serialize: httpSerialize +}) + +const https = /** @type {SchemeHandler} */ ({ + scheme: 'https', + domainHost: http.domainHost, + parse: httpParse, + serialize: httpSerialize +}) + +const ws = /** @type {SchemeHandler} */ ({ + scheme: 'ws', + domainHost: true, + parse: wsParse, + serialize: wsSerialize +}) + +const wss = /** @type {SchemeHandler} */ ({ + scheme: 'wss', + domainHost: ws.domainHost, + parse: ws.parse, + serialize: ws.serialize +}) + +const urn = /** @type {SchemeHandler} */ ({ + scheme: 'urn', + parse: urnParse, + serialize: urnSerialize, + skipNormalize: true +}) + +const urnuuid = /** @type {SchemeHandler} */ ({ + scheme: 'urn:uuid', + parse: urnuuidParse, + serialize: urnuuidSerialize, + skipNormalize: true +}) + +const SCHEMES = /** @type {Record} */ ({ + http, + https, + ws, + wss, + urn, + 'urn:uuid': urnuuid +}) + +Object.setPrototypeOf(SCHEMES, null) + +/** + * @param {string|undefined} scheme + * @returns {SchemeHandler|undefined} + */ +function getSchemeHandler (scheme) { + return ( + scheme && ( + SCHEMES[/** @type {SchemeName} */ (scheme)] || + SCHEMES[/** @type {SchemeName} */(scheme.toLowerCase())]) + ) || + undefined +} + +module.exports = { + wsIsSecure, + SCHEMES, + isValidSchemeName, + getSchemeHandler, +} diff --git a/tools/ui/node_modules/fast-uri/lib/utils.js b/tools/ui/node_modules/fast-uri/lib/utils.js new file mode 100644 index 0000000000000000000000000000000000000000..83639ee01681f2c93be84392368d92ede1c9adc2 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/lib/utils.js @@ -0,0 +1,443 @@ +'use strict' + +/** @type {(value: string) => boolean} */ +const isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu) + +/** @type {(value: string) => boolean} */ +const isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u) + +/** @type {(value: string) => boolean} */ +const isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu) + +/** @type {(value: string) => boolean} */ +const isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu) + +/** @type {(value: string) => boolean} */ +const isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu) + +/** + * @param {Array} input + * @returns {string} + */ +function stringArrayToHexStripped (input) { + let acc = '' + let code = 0 + let i = 0 + + for (i = 0; i < input.length; i++) { + code = input[i].charCodeAt(0) + if (code === 48) { + continue + } + if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) { + return '' + } + acc += input[i] + break + } + + for (i += 1; i < input.length; i++) { + code = input[i].charCodeAt(0) + if (!((code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102))) { + return '' + } + acc += input[i] + } + return acc +} + +/** + * @typedef {Object} GetIPV6Result + * @property {boolean} error - Indicates if there was an error parsing the IPv6 address. + * @property {string} address - The parsed IPv6 address. + * @property {string} [zone] - The zone identifier, if present. + */ + +/** + * @param {string} value + * @returns {boolean} + */ +const nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u) + +/** + * @param {Array} buffer + * @returns {boolean} + */ +function consumeIsZone (buffer) { + buffer.length = 0 + return true +} + +/** + * @param {Array} buffer + * @param {Array} address + * @param {GetIPV6Result} output + * @returns {boolean} + */ +function consumeHextets (buffer, address, output) { + if (buffer.length) { + const hex = stringArrayToHexStripped(buffer) + if (hex !== '') { + address.push(hex) + } else { + output.error = true + return false + } + buffer.length = 0 + } + return true +} + +/** + * @param {string} input + * @returns {GetIPV6Result} + */ +function getIPV6 (input) { + let tokenCount = 0 + const output = { error: false, address: '', zone: '' } + /** @type {Array} */ + const address = [] + /** @type {Array} */ + const buffer = [] + let endipv6Encountered = false + let endIpv6 = false + + let consume = consumeHextets + + for (let i = 0; i < input.length; i++) { + const cursor = input[i] + if (cursor === '[' || cursor === ']') { continue } + if (cursor === ':') { + if (endipv6Encountered === true) { + endIpv6 = true + } + if (!consume(buffer, address, output)) { break } + if (++tokenCount > 7) { + // not valid + output.error = true + break + } + if (i > 0 && input[i - 1] === ':') { + endipv6Encountered = true + } + address.push(':') + continue + } else if (cursor === '%') { + if (!consume(buffer, address, output)) { break } + // switch to zone detection + consume = consumeIsZone + } else { + buffer.push(cursor) + continue + } + } + if (buffer.length) { + if (consume === consumeIsZone) { + output.zone = buffer.join('') + } else if (endIpv6) { + address.push(buffer.join('')) + } else { + address.push(stringArrayToHexStripped(buffer)) + } + } + output.address = address.join('') + return output +} + +/** + * @typedef {Object} NormalizeIPv6Result + * @property {string} host - The normalized host. + * @property {string} [escapedHost] - The escaped host. + * @property {boolean} isIPV6 - Indicates if the host is an IPv6 address. + */ + +/** + * @param {string} host + * @returns {NormalizeIPv6Result} + */ +function normalizeIPv6 (host) { + if (findToken(host, ':') < 2) { return { host, isIPV6: false } } + const ipv6 = getIPV6(host) + + if (!ipv6.error) { + let newHost = ipv6.address + let escapedHost = ipv6.address + if (ipv6.zone) { + newHost += '%' + ipv6.zone + escapedHost += '%25' + ipv6.zone + } + return { host: newHost, isIPV6: true, escapedHost } + } else { + return { host, isIPV6: false } + } +} + +/** + * @param {string} str + * @param {string} token + * @returns {number} + */ +function findToken (str, token) { + let ind = 0 + for (let i = 0; i < str.length; i++) { + if (str[i] === token) ind++ + } + return ind +} + +/** + * @param {string} path + * @returns {string} + * + * @see https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4 + */ +function removeDotSegments (path) { + let input = path + const output = [] + let nextSlash = -1 + let len = 0 + + // eslint-disable-next-line no-cond-assign + while (len = input.length) { + if (len === 1) { + if (input === '.') { + break + } else if (input === '/') { + output.push('/') + break + } else { + output.push(input) + break + } + } else if (len === 2) { + if (input[0] === '.') { + if (input[1] === '.') { + break + } else if (input[1] === '/') { + input = input.slice(2) + continue + } + } else if (input[0] === '/') { + if (input[1] === '.' || input[1] === '/') { + output.push('/') + break + } + } + } else if (len === 3) { + if (input === '/..') { + if (output.length !== 0) { + output.pop() + } + output.push('/') + break + } + } + if (input[0] === '.') { + if (input[1] === '.') { + if (input[2] === '/') { + input = input.slice(3) + continue + } + } else if (input[1] === '/') { + input = input.slice(2) + continue + } + } else if (input[0] === '/') { + if (input[1] === '.') { + if (input[2] === '/') { + input = input.slice(2) + continue + } else if (input[2] === '.') { + if (input[3] === '/') { + input = input.slice(3) + if (output.length !== 0) { + output.pop() + } + continue + } + } + } + } + + // Rule 2E: Move normal path segment to output + if ((nextSlash = input.indexOf('/', 1)) === -1) { + output.push(input) + break + } else { + output.push(input.slice(0, nextSlash)) + input = input.slice(nextSlash) + } + } + + return output.join('') +} + +/** + * Re-escape RFC 3986 gen-delims that must not appear literally in the host. + * After the URI regex parses, these characters cannot be literal in the host + * field, so any that appear after decoding came from percent-encoding and + * must be restored to prevent authority structure changes. + * + * @param {string} host + * @param {boolean} isIP - true for IPv4/IPv6 hosts (skip colon re-escaping) + * @returns {string} + */ +const HOST_DELIMS = { '@': '%40', '/': '%2F', '?': '%3F', '#': '%23', ':': '%3A' } +const HOST_DELIM_RE = /[@/?#:]/g +const HOST_DELIM_NO_COLON_RE = /[@/?#]/g + +function reescapeHostDelimiters (host, isIP) { + const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE + re.lastIndex = 0 + return host.replace(re, (ch) => HOST_DELIMS[ch]) +} + +/** + * Normalizes percent escapes and optionally decodes only unreserved ASCII bytes. + * Reserved delimiters such as `%2F` and `%2E` stay escaped. + * + * @param {string} input + * @param {boolean} [decodeUnreserved=false] + * @returns {string} + */ +function normalizePercentEncoding (input, decodeUnreserved = false) { + if (input.indexOf('%') === -1) { + return input + } + + let output = '' + + for (let i = 0; i < input.length; i++) { + if (input[i] === '%' && i + 2 < input.length) { + const hex = input.slice(i + 1, i + 3) + if (isHexPair(hex)) { + const normalizedHex = hex.toUpperCase() + const decoded = String.fromCharCode(parseInt(normalizedHex, 16)) + + if (decodeUnreserved && isUnreserved(decoded)) { + output += decoded + } else { + output += '%' + normalizedHex + } + + i += 2 + continue + } + } + + output += input[i] + } + + return output +} + +/** + * Normalizes path data without turning reserved escapes into live path syntax. + * Valid escapes are uppercased, raw unsafe characters are escaped, and only + * unreserved bytes that are not `.` are decoded. + * + * @param {string} input + * @returns {string} + */ +function normalizePathEncoding (input) { + let output = '' + + for (let i = 0; i < input.length; i++) { + if (input[i] === '%' && i + 2 < input.length) { + const hex = input.slice(i + 1, i + 3) + if (isHexPair(hex)) { + const normalizedHex = hex.toUpperCase() + const decoded = String.fromCharCode(parseInt(normalizedHex, 16)) + + if (decoded !== '.' && isUnreserved(decoded)) { + output += decoded + } else { + output += '%' + normalizedHex + } + + i += 2 + continue + } + } + + if (isPathCharacter(input[i])) { + output += input[i] + } else { + output += escape(input[i]) + } + } + + return output +} + +/** + * Escapes a component while preserving existing valid percent escapes. + * + * @param {string} input + * @returns {string} + */ +function escapePreservingEscapes (input) { + let output = '' + + for (let i = 0; i < input.length; i++) { + if (input[i] === '%' && i + 2 < input.length) { + const hex = input.slice(i + 1, i + 3) + if (isHexPair(hex)) { + output += '%' + hex.toUpperCase() + i += 2 + continue + } + } + + output += escape(input[i]) + } + + return output +} + +/** + * @param {import('../types/index').URIComponent} component + * @returns {string|undefined} + */ +function recomposeAuthority (component) { + const uriTokens = [] + + if (component.userinfo !== undefined) { + uriTokens.push(component.userinfo) + uriTokens.push('@') + } + + if (component.host !== undefined) { + let host = unescape(component.host) + if (!isIPv4(host)) { + const ipV6res = normalizeIPv6(host) + if (ipV6res.isIPV6 === true) { + host = `[${ipV6res.escapedHost}]` + } else { + host = reescapeHostDelimiters(host, false) + } + } + uriTokens.push(host) + } + + if (typeof component.port === 'number' || typeof component.port === 'string') { + uriTokens.push(':') + uriTokens.push(String(component.port)) + } + + return uriTokens.length ? uriTokens.join('') : undefined +}; + +module.exports = { + nonSimpleDomain, + recomposeAuthority, + reescapeHostDelimiters, + normalizePercentEncoding, + normalizePathEncoding, + escapePreservingEscapes, + removeDotSegments, + isIPv4, + isUUID, + normalizeIPv6, + stringArrayToHexStripped +} diff --git a/tools/ui/node_modules/fast-uri/package.json b/tools/ui/node_modules/fast-uri/package.json new file mode 100644 index 0000000000000000000000000000000000000000..69bbc7ad181f34524601b1659d9f4dd95318f43b --- /dev/null +++ b/tools/ui/node_modules/fast-uri/package.json @@ -0,0 +1,68 @@ +{ + "name": "fast-uri", + "description": "Dependency-free RFC 3986 URI toolbox", + "version": "3.1.5", + "main": "index.js", + "type": "commonjs", + "types": "types/index.d.ts", + "license": "BSD-3-Clause", + "author": "Vincent Le Goff (https://github.com/zekth)", + "contributors": [ + { + "name": "Matteo Collina", + "email": "hello@matteocollina.com" + }, + { + "name": "Gürgün Dayıoğlu", + "email": "hey@gurgun.day", + "url": "https://heyhey.to/G" + }, + { + "name": "Aras Abbasi", + "email": "aras.abbasi@gmail.com" + }, + { + "name": "Frazer Smith", + "email": "frazer.dev@icloud.com", + "url": "https://github.com/fdawgs" + } + ], + "repository": { + "type": "git", + "url": "git+https://github.com/fastify/fast-uri.git" + }, + "bugs": { + "url": "https://github.com/fastify/fast-uri/issues" + }, + "homepage": "https://github.com/fastify/fast-uri", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fastify" + }, + { + "type": "opencollective", + "url": "https://opencollective.com/fastify" + } + ], + "scripts": { + "lint": "eslint", + "lint:fix": "eslint --fix", + "test": "npm run test:unit && npm run test:typescript", + "test:browser:chromium": "playwright-test ./test/* --runner tape --browser=chromium", + "test:browser:firefox": "playwright-test ./test/* --runner tape --browser=firefox", + "test:browser:webkit": "playwright-test ./test/* --runner tape --browser=webkit", + "test:browser": "npm run test:browser:chromium && npm run test:browser:firefox && npm run test:browser:webkit", + "test:unit": "tape test/**/*.js", + "test:unit:dev": "npm run test:unit -- --coverage-report=html", + "test:typescript": "tsd" + }, + "devDependencies": { + "ajv": "^8.16.0", + "eslint": "^9.17.0", + "neostandard": "^0.13.0", + "playwright-test": "^14.1.12", + "tape": "^5.8.1", + "tsd": "^0.33.0" + } +} diff --git a/tools/ui/node_modules/fast-uri/test/ajv.test.js b/tools/ui/node_modules/fast-uri/test/ajv.test.js new file mode 100644 index 0000000000000000000000000000000000000000..e6a44fe8bba623bf841a7c5193a5f0e99f71f059 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/ajv.test.js @@ -0,0 +1,43 @@ +'use strict' + +const test = require('tape') +const fastURI = require('..') + +const AJV = require('ajv') + +const ajv = new AJV({ + uriResolver: fastURI // comment this line to see it works with uri-js +}) + +test('ajv', t => { + t.plan(1) + const schema = { + $ref: '#/definitions/Record%3Cstring%2CPerson%3E', + definitions: { + Person: { + type: 'object', + properties: { + firstName: { + type: 'string' + } + } + }, + 'Record': { + type: 'object', + additionalProperties: { + $ref: '#/definitions/Person' + } + } + } + } + + const data = { + joe: { + firstName: 'Joe' + } + + } + + const validate = ajv.compile(schema) + t.ok(validate(data)) +}) diff --git a/tools/ui/node_modules/fast-uri/test/equal.test.js b/tools/ui/node_modules/fast-uri/test/equal.test.js new file mode 100644 index 0000000000000000000000000000000000000000..8ac1da44e6b5e13ff873ae28afb94b12a3552790 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/equal.test.js @@ -0,0 +1,117 @@ +'use strict' + +const test = require('tape') +const fastURI = require('..') + +const fn = fastURI.equal +const runTest = (t, suite) => { + suite.forEach(s => { + const operator = s.result ? '==' : '!=' + t.equal(fn(s.pair[0], s.pair[1]), s.result, `${s.pair[0]} ${operator} ${s.pair[1]}`) + t.equal(fn(s.pair[1], s.pair[0]), s.result, `${s.pair[1]} ${operator} ${s.pair[0]}`) + }) +} + +test('URI Equals', (t) => { + const suite = [ + { pair: ['example://a/b/c/%7Bfoo%7D', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d'], result: true }, // test from RFC 3986 + { pair: ['http://example.org/~user', 'http://example.org/%7euser'], result: true } // test from RFC 3987 + ] + runTest(t, suite) + t.end() +}) + +// test('IRI Equals', (t) => { +// // example from RFC 3987 +// t.equal(URI.equal('example://a/b/c/%7Bfoo%7D/ros\xE9', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d/ros%C3%A9', IRI_OPTION), true) +// t.end() +// }) + +test('HTTP Equals', (t) => { + const suite = [ + // test from RFC 2616 + { pair: ['http://abc.com:80/~smith/home.html', 'http://abc.com/~smith/home.html'], result: true }, + { pair: [{ scheme: 'http', host: 'abc.com', port: 80, path: '/~smith/home.html' }, 'http://abc.com/~smith/home.html'], result: true }, + { pair: ['http://ABC.com/%7Esmith/home.html', 'http://abc.com/~smith/home.html'], result: true }, + { pair: ['http://ABC.com:/%7esmith/home.html', 'http://abc.com/~smith/home.html'], result: true }, + { pair: ['HTTP://ABC.COM', 'http://abc.com/'], result: true }, + // test from RFC 3986 + { pair: ['http://example.com:/', 'http://example.com:80/'], result: true } + ] + runTest(t, suite) + t.end() +}) + +test('HTTPS Equals', (t) => { + const suite = [ + { pair: ['https://example.com', 'https://example.com:443/'], result: true }, + { pair: ['https://example.com:/', 'https://example.com:443/'], result: true } + ] + runTest(t, suite) + t.end() +}) + +test('URN Equals', (t) => { + const suite = [ + // test from RFC 2141 + { pair: ['urn:foo:a123,456', 'urn:foo:a123,456'], result: true }, + { pair: ['urn:foo:a123,456', 'URN:foo:a123,456'], result: true }, + { pair: ['urn:foo:a123,456', 'urn:FOO:a123,456'], result: true } + ] + + // Disabling for now as the whole equal logic might need + // to be refactored + // t.equal(URI.equal('urn:foo:a123,456', 'urn:foo:A123,456'), false) + // t.equal(URI.equal('urn:foo:a123%2C456', 'URN:FOO:a123%2c456'), true) + + runTest(t, suite) + + t.throws(() => { + fn('urn:', 'urn:FOO:a123,456') + }, 'URN without nid cannot be serialized') + + t.end() +}) + +test('UUID Equals', (t) => { + const suite = [ + { pair: ['URN:UUID:F81D4FAE-7DEC-11D0-A765-00A0C91E6BF6', 'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6'], result: true } + ] + + runTest(t, suite) + t.end() +}) + +// test('Mailto Equals', (t) => { +// // tests from RFC 6068 +// t.equal(URI.equal('mailto:addr1@an.example,addr2@an.example', 'mailto:?to=addr1@an.example,addr2@an.example'), true) +// t.equal(URI.equal('mailto:?to=addr1@an.example,addr2@an.example', 'mailto:addr1@an.example?to=addr2@an.example'), true) +// t.end() +// }) + +test('WS Equal', (t) => { + const suite = [ + { pair: ['WS://ABC.COM:80/chat#one', 'ws://abc.com/chat'], result: true } + ] + + runTest(t, suite) + t.end() +}) + +test('WSS Equal', (t) => { + const suite = [ + { pair: ['WSS://ABC.COM:443/chat#one', 'wss://abc.com/chat'], result: true } + ] + + runTest(t, suite) + t.end() +}) + +test('URI Equals tolerates malformed fragments', (t) => { + t.equal( + fastURI.equal('http://example.com/#%E0%A4A', 'http://example.com/#%E0%A4A'), + true, + 'malformed fragment does not throw during equality checks' + ) + t.end() +}) diff --git a/tools/ui/node_modules/fast-uri/test/fixtures/uri-js-parse.json b/tools/ui/node_modules/fast-uri/test/fixtures/uri-js-parse.json new file mode 100644 index 0000000000000000000000000000000000000000..6b848134ea8e6254f003f7c79eb0a926e0c87752 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/fixtures/uri-js-parse.json @@ -0,0 +1,501 @@ +[ + [ + "//www.g.com/error\n/bleh/bleh", + { + "host": "www.g.com", + "path": "/error%0A/bleh/bleh", + "reference": "relative" + } + ], + [ + "https://fastify.org", + { + "scheme": "https", + "host": "fastify.org", + "path": "", + "reference": "absolute" + } + ], + [ + "/definitions/Record%3Cstring%2CPerson%3E", + { + "path": "/definitions/Record%3Cstring%2CPerson%3E", + "reference": "relative" + } + ], + [ + "//10.10.10.10", + { + "host": "10.10.10.10", + "path": "", + "reference": "relative" + } + ], + [ + "//10.10.000.10", + { + "host": "10.10.0.10", + "path": "", + "reference": "relative" + } + ], + [ + "//[2001:db8::7%en0]", + { + "host": "2001:db8::7%en0", + "path": "", + "reference": "relative" + } + ], + [ + "//[2001:dbZ::1]:80", + { + "host": "[2001:dbz::1]", + "port": 80, + "path": "", + "reference": "relative" + } + ], + [ + "//[2001:db8::1]:80", + { + "host": "2001:db8::1", + "port": 80, + "path": "", + "reference": "relative" + } + ], + [ + "//[2001:db8::001]:80", + { + "host": "2001:db8::1", + "port": 80, + "path": "", + "reference": "relative" + } + ], + [ + "uri://user:pass@example.com:123/one/two.three?q1=a1&q2=a2#body", + { + "scheme": "uri", + "userinfo": "user:pass", + "host": "example.com", + "port": 123, + "path": "/one/two.three", + "query": "q1=a1&q2=a2", + "fragment": "body", + "reference": "uri" + } + ], + [ + "http://user:pass@example.com:123/one/space in.url?q1=a1&q2=a2#body", + { + "scheme": "http", + "userinfo": "user:pass", + "host": "example.com", + "port": 123, + "path": "/one/space%20in.url", + "query": "q1=a1&q2=a2", + "fragment": "body", + "reference": "uri" + } + ], + [ + "http://User:Pass@example.com:123/one/space in.url?q1=a1&q2=a2#body", + { + "scheme": "http", + "userinfo": "User:Pass", + "host": "example.com", + "port": 123, + "path": "/one/space%20in.url", + "query": "q1=a1&q2=a2", + "fragment": "body", + "reference": "uri" + } + ], + [ + "http://A%3AB@example.com:123/one/space", + { + "scheme": "http", + "userinfo": "A%3AB", + "host": "example.com", + "port": 123, + "path": "/one/space", + "reference": "absolute" + } + ], + [ + "//[::ffff:129.144.52.38]", + { + "host": "::ffff:129.144.52.38", + "path": "", + "reference": "relative" + } + ], + [ + "uri://10.10.10.10.example.com/en/process", + { + "scheme": "uri", + "host": "10.10.10.10.example.com", + "path": "/en/process", + "reference": "absolute" + } + ], + [ + "//[2606:2800:220:1:248:1893:25c8:1946]/test", + { + "host": "2606:2800:220:1:248:1893:25c8:1946", + "path": "/test", + "reference": "relative" + } + ], + [ + "ws://example.com/chat", + { + "scheme": "ws", + "host": "example.com", + "reference": "absolute", + "secure": false, + "resourceName": "/chat" + } + ], + [ + "ws://example.com/foo?bar=baz", + { + "scheme": "ws", + "host": "example.com", + "reference": "absolute", + "secure": false, + "resourceName": "/foo?bar=baz" + } + ], + [ + "wss://example.com/?bar=baz", + { + "scheme": "wss", + "host": "example.com", + "reference": "absolute", + "secure": true, + "resourceName": "/?bar=baz" + } + ], + [ + "wss://example.com/chat", + { + "scheme": "wss", + "host": "example.com", + "reference": "absolute", + "secure": true, + "resourceName": "/chat" + } + ], + [ + "wss://example.com/foo?bar=baz", + { + "scheme": "wss", + "host": "example.com", + "reference": "absolute", + "secure": true, + "resourceName": "/foo?bar=baz" + } + ], + [ + "wss://example.com/?bar=baz", + { + "scheme": "wss", + "host": "example.com", + "reference": "absolute", + "secure": true, + "resourceName": "/?bar=baz" + } + ], + [ + "urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6", + { + "scheme": "urn", + "reference": "absolute", + "nid": "uuid", + "uuid": "f81d4fae-7dec-11d0-a765-00a0c91e6bf6" + } + ], + [ + "urn:uuid:notauuid-7dec-11d0-a765-00a0c91e6bf6", + { + "scheme": "urn", + "reference": "absolute", + "nid": "uuid", + "uuid": "notauuid-7dec-11d0-a765-00a0c91e6bf6", + "error": "UUID is not valid." + } + ], + [ + "urn:example:%D0%B0123,z456", + { + "scheme": "urn", + "reference": "absolute", + "nid": "example", + "nss": "%D0%B0123,z456" + } + ], + [ + "//[2606:2800:220:1:248:1893:25c8:1946:43209]", + { + "host": "[2606:2800:220:1:248:1893:25c8:1946:43209]", + "path": "", + "reference": "relative" + } + ], + [ + "http://foo.bar", + { + "scheme": "http", + "host": "foo.bar", + "path": "", + "reference": "absolute" + } + ], + [ + "http://", + { + "scheme": "http", + "host": "", + "path": "", + "reference": "absolute", + "error": "HTTP URIs must have a host." + } + ], + [ + "#/$defs/stringMap", + { + "path": "", + "fragment": "/$defs/stringMap", + "reference": "same-document" + } + ], + [ + "#/$defs/string%20Map", + { + "path": "", + "fragment": "/$defs/string%20Map", + "reference": "same-document" + } + ], + [ + "#/$defs/string Map", + { + "path": "", + "fragment": "/$defs/string%20Map", + "reference": "same-document" + } + ], + [ + "//?json=%7B%22foo%22%3A%22bar%22%7D", + { + "host": "", + "path": "", + "query": "json=%7B%22foo%22%3A%22bar%22%7D", + "reference": "relative" + } + ], + [ + "mailto:chris@example.com", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "chris@example.com" + ] + } + ], + [ + "mailto:infobot@example.com?subject=current-issue", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "infobot@example.com" + ], + "subject": "current-issue" + } + ], + [ + "mailto:infobot@example.com?body=send%20current-issue", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "infobot@example.com" + ], + "body": "send current-issue" + } + ], + [ + "mailto:infobot@example.com?body=send%20current-issue%0D%0Asend%20index", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "infobot@example.com" + ], + "body": "send current-issue\r\nsend index" + } + ], + [ + "mailto:list@example.org?In-Reply-To=%3C3469A91.D10AF4C@example.com%3E", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "list@example.org" + ], + "headers": { + "In-Reply-To": "<3469A91.D10AF4C@example.com>" + } + } + ], + [ + "mailto:majordomo@example.com?body=subscribe%20bamboo-l", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "majordomo@example.com" + ], + "body": "subscribe bamboo-l" + } + ], + [ + "mailto:joe@example.com?cc=bob@example.com&body=hello", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "joe@example.com" + ], + "body": "hello", + "headers": { + "cc": "bob@example.com" + } + } + ], + [ + "mailto:gorby%25kremvax@example.com", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "gorby%kremvax@example.com" + ] + } + ], + [ + "mailto:unlikely%3Faddress@example.com?blat=foop", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "unlikely?address@example.com" + ], + "headers": { + "blat": "foop" + } + } + ], + [ + "mailto:Mike%26family@example.org", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "Mike&family@example.org" + ] + } + ], + [ + "mailto:%22not%40me%22@example.org", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "\"not@me\"@example.org" + ] + } + ], + [ + "mailto:%22oh%5C%5Cno%22@example.org", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "\"oh\\\\no\"@example.org" + ] + } + ], + [ + "mailto:%22%5C%5C%5C%22it's%5C%20ugly%5C%5C%5C%22%22@example.org", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "\"\\\\\\\"it's\\ ugly\\\\\\\"\"@example.org" + ] + } + ], + [ + "mailto:user@example.org?subject=caf%C3%A9", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "user@example.org" + ], + "subject": "café" + } + ], + [ + "mailto:user@example.org?subject=%3D%3Futf-8%3FQ%3Fcaf%3DC3%3DA9%3F%3D", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "user@example.org" + ], + "subject": "=?utf-8?Q?caf=C3=A9?=" + } + ], + [ + "mailto:user@example.org?subject=%3D%3Fiso-8859-1%3FQ%3Fcaf%3DE9%3F%3D", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "user@example.org" + ], + "subject": "=?iso-8859-1?Q?caf=E9?=" + } + ], + [ + "mailto:user@example.org?subject=caf%C3%A9&body=caf%C3%A9", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "user@example.org" + ], + "subject": "café", + "body": "café" + } + ], + [ + "mailto:user@%E7%B4%8D%E8%B1%86.example.org?subject=Test&body=NATTO", + { + "scheme": "mailto", + "reference": "absolute", + "to": [ + "user@xn--99zt52a.example.org" + ], + "subject": "Test", + "body": "NATTO" + } + ] +] \ No newline at end of file diff --git a/tools/ui/node_modules/fast-uri/test/fixtures/uri-js-serialize.json b/tools/ui/node_modules/fast-uri/test/fixtures/uri-js-serialize.json new file mode 100644 index 0000000000000000000000000000000000000000..87d7146797c473847daeb54a4921944d192e9478 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/fixtures/uri-js-serialize.json @@ -0,0 +1,120 @@ +[ + [ + { + "host": "10.10.10.10.example.com" + }, + "//10.10.10.10.example.com" + ], + [ + { + "host": "2001:db8::7" + }, + "//[2001:db8::7]" + ], + [ + { + "host": "::ffff:129.144.52.38" + }, + "//[::ffff:129.144.52.38]" + ], + [ + { + "host": "2606:2800:220:1:248:1893:25c8:1946" + }, + "//[2606:2800:220:1:248:1893:25c8:1946]" + ], + [ + { + "host": "10.10.10.10.example.com" + }, + "//10.10.10.10.example.com" + ], + [ + { + "host": "10.10.10.10" + }, + "//10.10.10.10" + ], + [ + { + "path": "?query" + }, + "%3Fquery" + ], + [ + { + "path": "foo:bar" + }, + "foo%3Abar" + ], + [ + { + "path": "//path" + }, + "/%2Fpath" + ], + [ + { + "scheme": "uri", + "host": "example.com", + "port": "9000" + }, + "uri://example.com:9000" + ], + [ + { + "scheme": "uri", + "userinfo": "foo:bar", + "host": "example.com", + "port": 1, + "path": "path", + "query": "query", + "fragment": "fragment" + }, + "uri://foo:bar@example.com:1/path?query#fragment" + ], + [ + { + "scheme": "", + "userinfo": "", + "host": "", + "port": 0, + "path": "", + "query": "", + "fragment": "" + }, + "//@:0?#" + ], + [ + {}, + "" + ], + [ + { + "host": "fe80::a%en1" + }, + "//[fe80::a%25en1]" + ], + [ + { + "host": "fe80::a%25en1" + }, + "//[fe80::a%25en1]" + ], + [ + { + "scheme": "wss", + "host": "example.com", + "path": "/foo", + "query": "bar" + }, + "wss://example.com/foo?bar" + ], + [ + { + "scheme": "scheme", + "path": "with:colon" + }, + "scheme:with:colon" + ] +] \ No newline at end of file diff --git a/tools/ui/node_modules/fast-uri/test/parse.test.js b/tools/ui/node_modules/fast-uri/test/parse.test.js new file mode 100644 index 0000000000000000000000000000000000000000..3b46b0282ae043bd6942c816b5ee606b10a4c18a --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/parse.test.js @@ -0,0 +1,323 @@ +'use strict' + +const test = require('tape') +const fastURI = require('..') + +test('URI parse', (t) => { + let components + + // scheme + components = fastURI.parse('uri:') + t.equal(components.error, undefined, 'scheme errors') + t.equal(components.scheme, 'uri', 'scheme') + // t.equal(components.authority, undefined, "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // userinfo + components = fastURI.parse('//@') + t.equal(components.error, undefined, 'userinfo errors') + t.equal(components.scheme, undefined, 'scheme') + // t.equal(components.authority, "@", "authority"); + t.equal(components.userinfo, '', 'userinfo') + t.equal(components.host, '', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // host + components = fastURI.parse('//') + t.equal(components.error, undefined, 'host errors') + t.equal(components.scheme, undefined, 'scheme') + // t.equal(components.authority, "", "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // port + components = fastURI.parse('//:') + t.equal(components.error, undefined, 'port errors') + t.equal(components.scheme, undefined, 'scheme') + // t.equal(components.authority, ":", "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '', 'host') + t.equal(components.port, '', 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // path + components = fastURI.parse('') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + // t.equal(components.authority, undefined, "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // query + components = fastURI.parse('?') + t.equal(components.error, undefined, 'query errors') + t.equal(components.scheme, undefined, 'scheme') + // t.equal(components.authority, undefined, "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, '', 'query') + t.equal(components.fragment, undefined, 'fragment') + + // fragment + components = fastURI.parse('#') + t.equal(components.error, undefined, 'fragment errors') + t.equal(components.scheme, undefined, 'scheme') + // t.equal(components.authority, undefined, "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '', 'fragment') + + // fragment with character tabulation + components = fastURI.parse('#\t') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + // t.equal(components.authority, undefined, "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '%09', 'fragment') + + // fragment with line feed + components = fastURI.parse('#\n') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + // t.equal(components.authority, undefined, "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '%0A', 'fragment') + + // fragment with line tabulation + components = fastURI.parse('#\v') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + // t.equal(components.authority, undefined, "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '%0B', 'fragment') + + // fragment with form feed + components = fastURI.parse('#\f') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + // t.equal(components.authority, undefined, "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '%0C', 'fragment') + + // fragment with carriage return + components = fastURI.parse('#\r') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + // t.equal(components.authority, undefined, "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '%0D', 'fragment') + + // malformed percent-encoded fragment must not throw + components = fastURI.parse('http://example.com/#%E0%A4A') + t.equal(components.error, 'URI malformed', 'malformed fragment errors') + t.equal(components.fragment, '%E0%A4A', 'malformed fragment is preserved') + + // all + components = fastURI.parse('uri://user:pass@example.com:123/one/two.three?q1=a1&q2=a2#body') + t.equal(components.error, undefined, 'all errors') + t.equal(components.scheme, 'uri', 'scheme') + // t.equal(components.authority, "user:pass@example.com:123", "authority"); + t.equal(components.userinfo, 'user:pass', 'userinfo') + t.equal(components.host, 'example.com', 'host') + t.equal(components.port, 123, 'port') + t.equal(components.path, '/one/two.three', 'path') + t.equal(components.query, 'q1=a1&q2=a2', 'query') + t.equal(components.fragment, 'body', 'fragment') + + // IPv4address + components = fastURI.parse('//10.10.10.10') + t.equal(components.error, undefined, 'IPv4address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '10.10.10.10', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // IPv4address with unformated 0 stay as-is + components = fastURI.parse('//10.10.000.10') // not valid as per https://datatracker.ietf.org/doc/html/rfc5954#section-4.1 + t.equal(components.error, undefined, 'IPv4address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '10.10.000.10', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + components = fastURI.parse('//01.01.01.01') // not valid in URIs: https://datatracker.ietf.org/doc/html/rfc3986#section-7.4 + t.equal(components.error, undefined, 'IPv4address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '01.01.01.01', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // IPv6address + components = fastURI.parse('//[2001:db8::7]') + t.equal(components.error, undefined, 'IPv4address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '2001:db8::7', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // invalid IPv6 + components = fastURI.parse('//[2001:dbZ::7]') + t.equal(components.host, '[2001:dbz::7]') + + // mixed IPv4address & IPv6address + components = fastURI.parse('//[::ffff:129.144.52.38]') + t.equal(components.error, undefined, 'IPv4address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '::ffff:129.144.52.38', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // mixed IPv4address & reg-name, example from terion-name (https://github.com/garycourt/uri-js/issues/4) + components = fastURI.parse('uri://10.10.10.10.example.com/en/process') + t.equal(components.error, undefined, 'mixed errors') + t.equal(components.scheme, 'uri', 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '10.10.10.10.example.com', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '/en/process', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // IPv6address, example from bkw (https://github.com/garycourt/uri-js/pull/16) + components = fastURI.parse('//[2606:2800:220:1:248:1893:25c8:1946]/test') + t.equal(components.error, undefined, 'IPv6address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '2606:2800:220:1:248:1893:25c8:1946', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '/test', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // IPv6address, example from RFC 5952 + components = fastURI.parse('//[2001:db8::1]:80') + t.equal(components.error, undefined, 'IPv6address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '2001:db8::1', 'host') + t.equal(components.port, 80, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // IPv6address with zone identifier, RFC 6874 + components = fastURI.parse('//[fe80::a%25en1]') + t.equal(components.error, undefined, 'IPv4address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, 'fe80::a%en1', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // IPv6address with an unescaped interface specifier, example from pekkanikander (https://github.com/garycourt/uri-js/pull/22) + components = fastURI.parse('//[2001:db8::7%en0]') + t.equal(components.error, undefined, 'IPv6address interface errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '2001:db8::7%en0', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // UUID V1 + components = fastURI.parse('urn:uuid:b571b0bc-4713-11ec-81d3-0242ac130003') + t.equal(components.error, undefined, 'errors') + t.equal(components.scheme, 'urn', 'scheme') + // t.equal(components.authority, undefined, "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, undefined, 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + t.equal(components.nid, 'uuid', 'nid') + t.equal(components.nss, undefined, 'nss') + t.equal(components.uuid, 'b571b0bc-4713-11ec-81d3-0242ac130003', 'uuid') + + // UUID v4 + components = fastURI.parse('urn:uuid:97a32222-89b7-420e-8507-4360723e2c2a') + t.equal(components.uuid, '97a32222-89b7-420e-8507-4360723e2c2a', 'uuid') + + components = fastURI.parse('urn:uuid:notauuid-7dec-11d0-a765-00a0c91e6bf6') + t.notSame(components.error, undefined, 'errors') + + components = fastURI.parse('urn:foo:a123,456') + t.equal(components.error, undefined, 'errors') + t.equal(components.scheme, 'urn', 'scheme') + // t.equal(components.authority, undefined, "authority"); + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, undefined, 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + t.equal(components.nid, 'foo', 'nid') + t.equal(components.nss, 'a123,456', 'nss') + + components = fastURI.parse('//[2606:2800:220:1:248:1893:25c8:1946:43209]') + t.equal(components.host, '[2606:2800:220:1:248:1893:25c8:1946:43209]') + + components = fastURI.parse('urn:foo:|\\24fpl') + t.equal(components.error, 'URN can not be parsed.') + t.end() +}) diff --git a/tools/ui/node_modules/fast-uri/test/resolve.test.js b/tools/ui/node_modules/fast-uri/test/resolve.test.js new file mode 100644 index 0000000000000000000000000000000000000000..b6c84679fa9795665f54563bcb816ef3c7a04358 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/resolve.test.js @@ -0,0 +1,87 @@ +'use strict' + +const test = require('tape') +const fastURI = require('..') + +test('URI Resolving', (t) => { + // normal examples from RFC 3986 + const base = 'uri://a/b/c/d;p?q' + t.equal(fastURI.resolve(base, 'g:h'), 'g:h', 'g:h') + t.equal(fastURI.resolve(base, 'g:h'), 'g:h', 'g:h') + t.equal(fastURI.resolve(base, 'g'), 'uri://a/b/c/g', 'g') + t.equal(fastURI.resolve(base, './g'), 'uri://a/b/c/g', './g') + t.equal(fastURI.resolve(base, 'g/'), 'uri://a/b/c/g/', 'g/') + t.equal(fastURI.resolve(base, '/g'), 'uri://a/g', '/g') + t.equal(fastURI.resolve(base, '//g'), 'uri://g', '//g') + t.equal(fastURI.resolve(base, '?y'), 'uri://a/b/c/d;p?y', '?y') + t.equal(fastURI.resolve(base, 'g?y'), 'uri://a/b/c/g?y', 'g?y') + t.equal(fastURI.resolve(base, '#s'), 'uri://a/b/c/d;p?q#s', '#s') + t.equal(fastURI.resolve(base, 'g#s'), 'uri://a/b/c/g#s', 'g#s') + t.equal(fastURI.resolve(base, 'g?y#s'), 'uri://a/b/c/g?y#s', 'g?y#s') + t.equal(fastURI.resolve(base, ';x'), 'uri://a/b/c/;x', ';x') + t.equal(fastURI.resolve(base, 'g;x'), 'uri://a/b/c/g;x', 'g;x') + t.equal(fastURI.resolve(base, 'g;x?y#s'), 'uri://a/b/c/g;x?y#s', 'g;x?y#s') + t.equal(fastURI.resolve(base, ''), 'uri://a/b/c/d;p?q', '') + t.equal(fastURI.resolve(base, '.'), 'uri://a/b/c/', '.') + t.equal(fastURI.resolve(base, './'), 'uri://a/b/c/', './') + t.equal(fastURI.resolve(base, '..'), 'uri://a/b/', '..') + t.equal(fastURI.resolve(base, '../'), 'uri://a/b/', '../') + t.equal(fastURI.resolve(base, '../g'), 'uri://a/b/g', '../g') + t.equal(fastURI.resolve(base, '../..'), 'uri://a/', '../..') + t.equal(fastURI.resolve(base, '../../'), 'uri://a/', '../../') + t.equal(fastURI.resolve(base, '../../g'), 'uri://a/g', '../../g') + + // abnormal examples from RFC 3986 + t.equal(fastURI.resolve(base, '../../../g'), 'uri://a/g', '../../../g') + t.equal(fastURI.resolve(base, '../../../../g'), 'uri://a/g', '../../../../g') + + t.equal(fastURI.resolve(base, '/./g'), 'uri://a/g', '/./g') + t.equal(fastURI.resolve(base, '/../g'), 'uri://a/g', '/../g') + t.equal(fastURI.resolve(base, 'g.'), 'uri://a/b/c/g.', 'g.') + t.equal(fastURI.resolve(base, '.g'), 'uri://a/b/c/.g', '.g') + t.equal(fastURI.resolve(base, 'g..'), 'uri://a/b/c/g..', 'g..') + t.equal(fastURI.resolve(base, '..g'), 'uri://a/b/c/..g', '..g') + + t.equal(fastURI.resolve(base, './../g'), 'uri://a/b/g', './../g') + t.equal(fastURI.resolve(base, './g/.'), 'uri://a/b/c/g/', './g/.') + t.equal(fastURI.resolve(base, 'g/./h'), 'uri://a/b/c/g/h', 'g/./h') + t.equal(fastURI.resolve(base, 'g/../h'), 'uri://a/b/c/h', 'g/../h') + t.equal(fastURI.resolve(base, 'g;x=1/./y'), 'uri://a/b/c/g;x=1/y', 'g;x=1/./y') + t.equal(fastURI.resolve(base, 'g;x=1/../y'), 'uri://a/b/c/y', 'g;x=1/../y') + + t.equal(fastURI.resolve(base, 'g?y/./x'), 'uri://a/b/c/g?y/./x', 'g?y/./x') + t.equal(fastURI.resolve(base, 'g?y/../x'), 'uri://a/b/c/g?y/../x', 'g?y/../x') + t.equal(fastURI.resolve(base, 'g#s/./x'), 'uri://a/b/c/g#s/./x', 'g#s/./x') + t.equal(fastURI.resolve(base, 'g#s/../x'), 'uri://a/b/c/g#s/../x', 'g#s/../x') + + t.equal(fastURI.resolve(base, 'uri:g'), 'uri:g', 'uri:g') + t.equal(fastURI.resolve(base, 'uri:g', {}), 'uri:g', 'uri:g') + t.equal(fastURI.resolve(base, 'uri:g', { tolerant: undefined }), 'uri:g', 'uri:g') + t.equal(fastURI.resolve(base, 'uri:g', { tolerant: false }), 'uri:g', 'uri:g') + t.equal(fastURI.resolve(base, 'uri:g', { tolerant: true }), 'uri://a/b/c/g', 'uri:g') + + // examples by PAEz + // example was provided to avoid infinite loop within regex + // this is not the case anymore + // t.equal(URI.resolve('//www.g.com/', '/adf\ngf'), '//www.g.com/adf%0Agf', '/adf\\ngf') + // t.equal(URI.resolve('//www.g.com/error\n/bleh/bleh', '..'), '//www.g.com/error%0A/', '//www.g.com/error\\n/bleh/bleh') + t.end() +}) + +test('URN Resolving', (t) => { + // example from epoberezkin + t.equal(fastURI.resolve('', 'urn:some:ip:prop'), 'urn:some:ip:prop', 'urn:some:ip:prop') + t.equal(fastURI.resolve('#', 'urn:some:ip:prop'), 'urn:some:ip:prop', 'urn:some:ip:prop') + t.equal(fastURI.resolve('urn:some:ip:prop', 'urn:some:ip:prop'), 'urn:some:ip:prop', 'urn:some:ip:prop') + t.equal(fastURI.resolve('urn:some:other:prop', 'urn:some:ip:prop'), 'urn:some:ip:prop', 'urn:some:ip:prop') + t.end() +}) + +test('URI Resolving tolerates malformed fragments', (t) => { + t.equal( + fastURI.resolve('http://base.com/', 'http://example.com/#%E0%A4A'), + 'http://example.com/#%E0%A4A', + 'malformed fragment does not throw during resolve' + ) + t.end() +}) diff --git a/tools/ui/node_modules/fast-uri/test/rfc-3986.test.js b/tools/ui/node_modules/fast-uri/test/rfc-3986.test.js new file mode 100644 index 0000000000000000000000000000000000000000..0a5adbeccaea3604a45e8ffdd30839bcf3935ea1 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/rfc-3986.test.js @@ -0,0 +1,90 @@ +'use strict' + +const test = require('tape') +const fastURI = require('..') + +test('RFC 3986', (t) => { + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/foo', secure: true }), + 'http://example.com/foo', 'http://example.com/foo') + + // A. If the input buffer begins with a prefix of "../" or "./", + // then remove that prefix from the input buffer; otherwise, + + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '../', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: './', secure: true }), + 'http://example.com/', 'http://example.com/') + + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '../../', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '././', secure: true }), + 'http://example.com/', 'http://example.com/') + + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: './../', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '.././', secure: true }), + 'http://example.com/', 'http://example.com/') + + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '../foo', secure: true }), + 'http://example.com/foo', 'http://example.com/foo') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: './foo', secure: true }), + 'http://example.com/foo', 'http://example.com/foo') + + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '../../foo', secure: true }), + 'http://example.com/foo', 'http://example.com/foo') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '././foo', secure: true }), + 'http://example.com/foo', 'http://example.com/foo') + + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: './../foo', secure: true }), + 'http://example.com/foo', 'http://example.com/foo') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '.././foo', secure: true }), + 'http://example.com/foo', 'http://example.com/foo') + + // B. if the input buffer begins with a prefix of "/./" or "/.", + // where "." is a complete path segment, then replace that + // prefix with "/" in the input buffer; otherwise, + + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/./', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/.', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/./foo', secure: true }), + 'http://example.com/foo', 'http://example.com/foo') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/.././foo', secure: true }), + 'http://example.com/foo', 'http://example.com/foo') + + // C. if the input buffer begins with a prefix of "/../" or "/..", + // where ".." is a complete path segment, then replace that + // prefix with "/" in the input buffer and remove the last + // segment and its preceding "/" (if any) from the output + // buffer; otherwise, + + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/../', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/..', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/../foo', secure: true }), + 'http://example.com/foo', 'http://example.com/foo') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/foo/..', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/foo/bar/..', secure: true }), + 'http://example.com/foo/', 'http://example.com/foo/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/foo/../bar/..', secure: true }), + 'http://example.com/', 'http://example.com/') + + // D. if the input buffer consists only of "." or "..", then remove + // that from the input buffer; otherwise, + + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/.', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '/..', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '.', secure: true }), + 'http://example.com/', 'http://example.com/') + t.strictEqual(fastURI.serialize({ scheme: 'http', host: 'example.com', path: '..', secure: true }), + 'http://example.com/', 'http://example.com/') + + t.end() +}) diff --git a/tools/ui/node_modules/fast-uri/test/security-normalization.test.js b/tools/ui/node_modules/fast-uri/test/security-normalization.test.js new file mode 100644 index 0000000000000000000000000000000000000000..f97fb124007a9cebb29502bfcb746519783075b9 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/security-normalization.test.js @@ -0,0 +1,39 @@ +'use strict' + +const test = require('tape') +const fastURI = require('..') + +test('parse preserves reserved path escapes as data', (t) => { + const components = fastURI.parse('http://example.com/a%2Fb/public/%2e%2e/admin') + + t.equal(components.path, '/a%2Fb/public/%2E%2E/admin') + t.end() +}) + +test('normalize preserves percent-encoded path separators and dot segments', (t) => { + t.equal( + fastURI.normalize('http://example.com/public/%2e%2e/admin'), + 'http://example.com/public/%2E%2E/admin' + ) + + t.equal( + fastURI.normalize('http://example.com/a%2Fb'), + 'http://example.com/a%2Fb' + ) + + t.end() +}) + +test('equal does not treat reserved path escapes as live path syntax', (t) => { + t.equal( + fastURI.equal('http://example.com/public/%2e%2e/admin', 'http://example.com/admin', {}), + false + ) + + t.equal( + fastURI.equal('http://example.com/a%2Fb', 'http://example.com/a/b', {}), + false + ) + + t.end() +}) diff --git a/tools/ui/node_modules/fast-uri/test/security.test.js b/tools/ui/node_modules/fast-uri/test/security.test.js new file mode 100644 index 0000000000000000000000000000000000000000..4c11cf24f21df52d41328a28aed1f642974a6f3b --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/security.test.js @@ -0,0 +1,359 @@ +'use strict' + +const test = require('tape') +const fastURI = require('..') + +test('parse marks malformed authority and port inputs as errors', (t) => { + const malformedCases = [ + { + input: 'http://[::1]foo', + expectedError: 'URI path must start with "/" when authority is present.' + }, + { + input: 'http://[::1]:80abc/path', + expectedError: 'URI path must start with "/" when authority is present.' + }, + { + input: 'http://example.com:80abc/path', + expectedError: 'URI path must start with "/" when authority is present.' + }, + { + input: 'http://[::1]:65536', + expectedError: 'URI port is malformed.' + } + ] + + t.plan(malformedCases.length) + + malformedCases.forEach(({ input, expectedError }) => { + t.equal(fastURI.parse(input).error, expectedError, input) + }) +}) + +test('normalize does not canonicalize malformed URLs into different valid URLs', (t) => { + const malformedCases = [ + 'http://[::1]foo', + 'http://[::1]:80abc/path', + 'http://example.com:80abc/path', + 'http://[::1]:65536' + ] + + t.plan(malformedCases.length) + + malformedCases.forEach((input) => { + t.equal(fastURI.normalize(input), input, input) + }) +}) + +test('equal returns false when either side is malformed', (t) => { + const malformedPairs = [ + ['http://[::1]foo', 'http://[::1]/foo'], + ['http://[::1]:80abc/path', 'http://[::1]/abc/path'], + ['http://example.com:80abc/path', 'http://example.com/abc/path'], + ['http://[::1]:65536', 'http://[::1]:65536/'] + ] + + t.plan(malformedPairs.length) + + malformedPairs.forEach(([left, right]) => { + t.equal(fastURI.equal(left, right), false, `${left} != ${right}`) + }) +}) + +test('normalize preserves encoded authority delimiters in host', (t) => { + const cases = [ + ['http://trusted.com%40evil.com/', 'http://trusted.com%40evil.com/'], + ['http://example.com%3A8080/', 'http://example.com%3A8080/'], + ['http://example.com%2Fevil.com/path', 'http://example.com%2Fevil.com/path'], + ['http://example.com%23fragment/path', 'http://example.com%23fragment/path'], + ['http://example.com%3Fq=evil/path', 'http://example.com%3Fq=evil/path'], + ['http://user%3Apass%40evil.com/', 'http://user%3Apass%40evil.com/'], + ['http://user@trusted.com%40evil.com/', 'http://user@trusted.com%40evil.com/'], + ['https://trusted.com%40evil.com/', 'https://trusted.com%40evil.com/'], + ['ws://trusted.com%40evil.com/chat', 'ws://trusted.com%40evil.com/chat'], + ['wss://trusted.com%40evil.com/chat', 'wss://trusted.com%40evil.com/chat'] + ] + + t.plan(cases.length) + + cases.forEach(([input, expected]) => { + t.equal(fastURI.normalize(input), expected, input) + }) +}) + +test('parse preserves encoded authority delimiters in host', (t) => { + const cases = [ + ['http://trusted.com%40evil.com/', 'trusted.com%40evil.com'], + ['http://example.com%3A8080/', 'example.com%3A8080'], + ['http://user%3Apass%40evil.com/', 'user%3Apass%40evil.com'] + ] + + t.plan(cases.length) + + cases.forEach(([input, expectedHost]) => { + t.equal(fastURI.parse(input).host, expectedHost, input) + }) +}) + +test('equal returns false when encoded delimiters differ from live delimiters', (t) => { + const pairs = [ + ['http://trusted.com%40evil.com/', 'http://trusted.com@evil.com/'], + ['http://example.com%3A8080/', 'http://example.com:8080/'] + ] + + t.plan(pairs.length) + + pairs.forEach(([left, right]) => { + t.equal(fastURI.equal(left, right, {}), false, `${left} != ${right}`) + }) +}) + +test('resolve preserves encoded authority delimiters', (t) => { + const result = fastURI.resolve('http://base.com/', '//trusted.com%40evil.com/path') + const parsed = fastURI.parse(result) + + t.plan(1) + t.notEqual(parsed.host, 'evil.com', '//trusted.com%40evil.com/path') +}) + +test('serialize escapes authority delimiters in host field', (t) => { + const result = fastURI.serialize({ scheme: 'http', host: 'trusted.com@evil.com', path: '/' }) + const parsed = fastURI.parse(result) + + t.plan(1) + t.notEqual(parsed.host, 'evil.com', 'host: trusted.com@evil.com') +}) + +test('normalize does not double-decode %2540 into a live @', (t) => { + const result = fastURI.normalize('http://trusted.com%2540evil.com/') + const parsed = fastURI.parse(result) + + t.plan(1) + t.notEqual(parsed.host, 'trusted.com@evil.com', 'http://trusted.com%2540evil.com/') +}) + +test('parse canonicalises IDN / Unicode hosts to their ASCII form', (t) => { + const cases = [ + { + input: 'http://127。0。0。1/', + expectedHost: '127.0.0.1', + description: 'full-width ideographic stops as octet separators' + }, + { + input: 'http://ｅxample.com/', + expectedHost: 'example.com', + description: 'fullwidth e as first letter' + }, + { + input: 'http://納豆.example.org/', + expectedHost: 'xn--99zt52a.example.org', + description: 'CJK label requiring punycode' + } + ] + + t.plan(cases.length * 2) + + cases.forEach(({ input, expectedHost, description }) => { + const parsed = fastURI.parse(input) + t.notOk(parsed.error, `parse should not set error: ${description}`) + t.equal(parsed.host, expectedHost, `host canonicalised to ASCII: ${description}`) + }) +}) + +test('parse rejects a literal backslash in the authority as malformed (RFC 3986)', (t) => { + // Regression for the host-confusion bypass: a literal "\" is invalid RFC 3986 + // syntax and must be flagged malformed, not silently rewritten. Otherwise "\" + // acts as a host delimiter here while Node's native URL parses a different + // host, defeating a host-based SSRF/redirect/origin allowlist. + const cases = [ + 'http://evil.com\\@allowed.com', + 'https://169.254.169.254\\@trusted.example.com', + 'http://127.0.0.1\\@public.example.com', + 'https://attacker.com\\@api.internal', + 'http://a\\@b', + 'ws://evil.com\\@allowed.com/chat', + 'wss://evil.com\\@allowed.com/chat', + 'http://evil.com\\%40allowed.com', + '//evil.com\\@allowed.com' + ] + + t.plan(cases.length) + + cases.forEach((input) => { + t.equal( + fastURI.parse(input).error, + 'URI authority must not contain a literal backslash.', + input + ) + }) +}) + +test('normalize does not canonicalize a literal-backslash URI into a different valid URL', (t) => { + const cases = [ + 'http://evil.com\\@allowed.com', + 'https://attacker.com\\@api.internal' + ] + + t.plan(cases.length) + + cases.forEach((input) => { + t.equal(fastURI.normalize(input), input, input) + }) +}) + +test('parse leaves percent-encoded %5C untouched as encoded data (not rejected)', (t) => { + // Only the literal "\" byte is rejected; %5C stays valid encoded data and + // does not diverge from the native URL parser, so it must not be flagged. + const input = 'http://evil.com%5C@allowed.com' + const parsed = fastURI.parse(input) + + t.plan(2) + t.notOk(parsed.error, '%5C is valid encoded data, not malformed') + t.equal(parsed.host, new URL(input).hostname, '%5C host matches native URL (no divergence)') +}) + +test('parse does not reject a literal backslash in the query or fragment', (t) => { + // The rejection is scoped to the authority/path (the host-confusion surface); + // a backslash after "?"/"#" is normalized as encoded data as before. + const parsed = fastURI.parse('http://host.example.com/?x=\\y#z\\w') + + t.plan(2) + t.notOk(parsed.error, 'backslash in query/fragment does not mark the URI malformed') + t.equal(parsed.host, 'host.example.com', 'host parsed normally') +}) + +test('parse rejects a malformed authority introducer (\\\\, /\\, \\/) in place of //', (t) => { + // Regression: "\\", "/\\", "\\/" after the scheme colon are not valid authority + // introducers. Node's URL treats "\\" as interchangeable with "/" on special + // schemes, so "http:\\\\evil.com/path" would be parsed as host "evil.com" by + // Node, but fast-uri must reject it as malformed to prevent SSRF/redirect bypass. + const cases = [ + 'http:\\\\evil.com/path', + 'http:/\\evil.com/path', + 'http:\\/evil.com/path', + 'ws:\\\\evil.com/chat', + 'wss:\\\\evil.com/chat', + 'ftp:\\\\evil.com/', + '\\\\evil.com/path' + ] + + t.plan(cases.length) + + cases.forEach((input) => { + t.equal( + fastURI.parse(input).error, + 'URI authority must not contain a literal backslash.', + input + ) + }) +}) + +test('normalize does not canonicalize a malformed-authority-introducer URI', (t) => { + const cases = [ + 'http:\\\\evil.com/path', + 'http:/\\evil.com/path' + ] + + t.plan(cases.length) + + cases.forEach((input) => { + t.equal(fastURI.normalize(input), input, input) + }) +}) + +test('equal returns false for malformed-authority-introducer URIs', (t) => { + const pairs = [ + ['http:\\\\evil.com/path', 'http://evil.com/path'], + ['http:/\\evil.com/path', 'http://evil.com/path'] + ] + + t.plan(pairs.length) + + pairs.forEach(([left, right]) => { + t.equal(fastURI.equal(left, right), false, `${left} != ${right}`) + }) +}) + +test('resolve throws on malformed authority introducer', (t) => { + // resolve() returns a plain string with no error field, so the only safe + // behavior is to throw when either component has a malformed authority. + const pairs = [ + ['https://allowed.com/', '\\\\evil.com/path'], + ['\\\\evil.com/path', 'https://allowed.com/'], + ['https://allowed.com/', 'http:/\\evil.com/path'], + ['https://allowed.com/', 'http:\\/evil.com/path'] + ] + + t.plan(pairs.length) + + pairs.forEach(([base, rel]) => { + t.throws( + () => fastURI.resolve(base, rel), + /URI authority must not contain a literal backslash/, + `${base} + ${rel}` + ) + }) +}) + +test('parse rejects a whitespace-split authority introducer (TAB, LF, CR)', (t) => { + // The WHATWG URL parser removes TAB (U+0009), LF (U+000A) and CR (U+000D) from + // the input before parsing, so a stripped character wedged into the introducer + // ("/\\", "//", or a leading "//") reaches an authority in Node + // while fast-uri would otherwise fold it into the path. These must be rejected + // like the adjacent "\\", "/\\", "\\/" forms. + const cases = [ + { input: '/\t\\evil.com/path', expectedError: 'URI authority must not contain a literal backslash.' }, + { input: '/\t/evil.com/path', expectedError: 'URI authority introducer must not contain whitespace.' }, + { input: '/\n\\evil.com/path', expectedError: 'URI authority must not contain a literal backslash.' }, + { input: '/\r\\evil.com/path', expectedError: 'URI authority must not contain a literal backslash.' }, + { input: '\t//evil.com/path', expectedError: 'URI authority introducer must not contain whitespace.' }, + { input: '\t/\\evil.com/path', expectedError: 'URI authority must not contain a literal backslash.' }, + { input: 'https:/\t/evil.com/path', expectedError: 'URI authority introducer must not contain whitespace.' } + ] + + t.plan(cases.length) + + cases.forEach(({ input, expectedError }) => { + t.equal(fastURI.parse(input).error, expectedError, JSON.stringify(input)) + }) +}) + +test('resolve throws on a whitespace-split authority introducer', (t) => { + const pairs = [ + ['https://allowed.com/', '/\t\\evil.com/path'], + ['https://allowed.com/', '/\t/evil.com/path'], + ['https://allowed.com/', '/\n\\evil.com/path'], + ['/\t/evil.com/path', 'https://allowed.com/'] + ] + + t.plan(pairs.length) + + pairs.forEach(([base, rel]) => { + t.throws( + () => fastURI.resolve(base, rel), + /URI authority (must not contain a literal backslash|introducer must not contain whitespace)/, + `${JSON.stringify(base)} + ${JSON.stringify(rel)}` + ) + }) +}) + +test('parse does not reject valid authority introducer patterns', (t) => { + // No false positives: "//" introducer and scheme-less "//" must be valid. + const cases = [ + 'http://good.com/', + 'https://good.com/', + 'ws://good.com/chat', + 'wss://good.com/chat', + 'ftp://good.com/', + '//good.com/path', + '/absolute/path', + 'relative/path' + ] + + t.plan(cases.length) + + cases.forEach((input) => { + const parsed = fastURI.parse(input) + t.notOk(parsed.error, input) + }) +}) diff --git a/tools/ui/node_modules/fast-uri/test/serialize.test.js b/tools/ui/node_modules/fast-uri/test/serialize.test.js new file mode 100644 index 0000000000000000000000000000000000000000..0eaa346aba23a2e3855a2330aa13c6c09317c743 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/serialize.test.js @@ -0,0 +1,151 @@ +'use strict' + +const test = require('tape') +const fastURI = require('..') + +test('URI Serialize', (t) => { + let components = { + scheme: undefined, + userinfo: undefined, + host: undefined, + port: undefined, + path: undefined, + query: undefined, + fragment: undefined + } + t.equal(fastURI.serialize(components), '', 'Undefined Components') + + components = { + scheme: '', + userinfo: '', + host: '', + port: 0, + path: '', + query: '', + fragment: '' + } + t.equal(fastURI.serialize(components), '//@:0?#', 'Empty Components') + + components = { + scheme: 'uri', + userinfo: 'foo:bar', + host: 'example.com', + port: 1, + path: 'path', + query: 'query', + fragment: 'fragment' + } + t.equal(fastURI.serialize(components), 'uri://foo:bar@example.com:1/path?query#fragment', 'All Components') + + components = { + scheme: 'uri', + host: 'example.com', + port: '9000' + } + t.equal(fastURI.serialize(components), 'uri://example.com:9000', 'String port') + + t.equal(fastURI.serialize({ path: '//path' }), '/%2Fpath', 'Double slash path') + t.equal(fastURI.serialize({ path: 'foo:bar' }), 'foo%3Abar', 'Colon path') + t.equal(fastURI.serialize({ path: '?query' }), '%3Fquery', 'Query path') + + t.equal(fastURI.serialize({ host: '10.10.10.10' }), '//10.10.10.10', 'IPv4address') + + // mixed IPv4address & reg-name, example from terion-name (https://github.com/garycourt/uri-js/issues/4) + t.equal(fastURI.serialize({ host: '10.10.10.10.example.com' }), '//10.10.10.10.example.com', 'Mixed IPv4address & reg-name') + + // IPv6address + t.equal(fastURI.serialize({ host: '2001:db8::7' }), '//[2001:db8::7]', 'IPv6 Host') + t.equal(fastURI.serialize({ host: '::ffff:129.144.52.38' }), '//[::ffff:129.144.52.38]', 'IPv6 Mixed Host') + t.equal(fastURI.serialize({ host: '2606:2800:220:1:248:1893:25c8:1946' }), '//[2606:2800:220:1:248:1893:25c8:1946]', 'IPv6 Full Host') + + // IPv6address with zone identifier, RFC 6874 + t.equal(fastURI.serialize({ host: 'fe80::a%en1' }), '//[fe80::a%25en1]', 'IPv6 Zone Unescaped Host') + t.equal(fastURI.serialize({ host: 'fe80::a%25en1' }), '//[fe80::a%25en1]', 'IPv6 Zone Escaped Host') + + t.end() +}) + +test('WS serialize', (t) => { + t.equal(fastURI.serialize({ scheme: 'ws' }), 'ws:') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com' }), 'ws://example.com') + t.equal(fastURI.serialize({ scheme: 'ws', resourceName: '/' }), 'ws:') + t.equal(fastURI.serialize({ scheme: 'ws', resourceName: '/foo' }), 'ws:/foo') + t.equal(fastURI.serialize({ scheme: 'ws', resourceName: '/foo?bar' }), 'ws:/foo?bar') + t.equal(fastURI.serialize({ scheme: 'ws', secure: false }), 'ws:') + t.equal(fastURI.serialize({ scheme: 'ws', secure: true }), 'wss:') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo' }), 'ws://example.com/foo') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar' }), 'ws://example.com/foo?bar') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', secure: false }), 'ws://example.com') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', secure: true }), 'wss://example.com') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: false }), 'ws://example.com/foo?bar') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: true }), 'wss://example.com/foo?bar') + t.end() +}) + +test('WSS serialize', (t) => { + t.equal(fastURI.serialize({ scheme: 'wss' }), 'wss:') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com' }), 'wss://example.com') + t.equal(fastURI.serialize({ scheme: 'wss', resourceName: '/' }), 'wss:') + t.equal(fastURI.serialize({ scheme: 'wss', resourceName: '/foo' }), 'wss:/foo') + t.equal(fastURI.serialize({ scheme: 'wss', resourceName: '/foo?bar' }), 'wss:/foo?bar') + t.equal(fastURI.serialize({ scheme: 'wss', secure: false }), 'ws:') + t.equal(fastURI.serialize({ scheme: 'wss', secure: true }), 'wss:') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo' }), 'wss://example.com/foo') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo?bar' }), 'wss://example.com/foo?bar') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', secure: false }), 'ws://example.com') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', secure: true }), 'wss://example.com') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo?bar', secure: false }), 'ws://example.com/foo?bar') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo?bar', secure: true }), 'wss://example.com/foo?bar') + + t.end() +}) + +test('URN serialize', (t) => { + // example from RFC 2141 + const components = { + scheme: 'urn', + nid: 'foo', + nss: 'a123,456' + } + t.equal(fastURI.serialize(components), 'urn:foo:a123,456') + // example from RFC 4122 + let uuidcomponents = { + scheme: 'urn', + nid: 'uuid', + uuid: 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6' + } + t.equal(fastURI.serialize(uuidcomponents), 'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6') + + uuidcomponents = { + scheme: 'urn', + nid: 'uuid', + uuid: 'notauuid-7dec-11d0-a765-00a0c91e6bf6' + } + t.equal(fastURI.serialize(uuidcomponents), 'urn:uuid:notauuid-7dec-11d0-a765-00a0c91e6bf6') + + uuidcomponents = { + scheme: 'urn', + nid: undefined, + uuid: 'notauuid-7dec-11d0-a765-00a0c91e6bf6' + } + t.throws(() => { fastURI.serialize(uuidcomponents) }, 'URN without nid cannot be serialized') + + t.end() +}) +test('URN NID Override', (t) => { + let components = fastURI.parse('urn:foo:f81d4fae-7dec-11d0-a765-00a0c91e6bf6', { nid: 'uuid' }) + t.equal(components.error, undefined, 'errors') + t.equal(components.scheme, 'urn', 'scheme') + t.equal(components.path, undefined, 'path') + t.equal(components.nid, 'foo', 'nid') + t.equal(components.nss, undefined, 'nss') + t.equal(components.uuid, 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6', 'uuid') + + components = { + scheme: 'urn', + nid: 'foo', + uuid: 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6' + } + t.equal(fastURI.serialize(components, { nid: 'uuid' }), 'urn:foo:f81d4fae-7dec-11d0-a765-00a0c91e6bf6') + t.end() +}) diff --git a/tools/ui/node_modules/fast-uri/test/uri-js-compatibility.test.js b/tools/ui/node_modules/fast-uri/test/uri-js-compatibility.test.js new file mode 100644 index 0000000000000000000000000000000000000000..a75869b18c8af470de4999dfb533f2305d44b450 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/uri-js-compatibility.test.js @@ -0,0 +1,33 @@ +'use strict' + +const test = require('tape') +const fastURI = require('../') + +const uriJsParseFixtures = require('./fixtures/uri-js-parse.json') +const uriJsSerializeFixtures = require('./fixtures/uri-js-serialize.json') + +test('uri-js compatibility Parse', (t) => { + uriJsParseFixtures.forEach(( + [value, expected] + ) => { + if (value === '//10.10.000.10') { + return t.skip('Skipping //10.10.000.10 as it is not a valid URI per URI spec: https://datatracker.ietf.org/doc/html/rfc5954#section-4.1') + } + if (value.slice(0, 6) === 'mailto') { + return t.skip('Skipping mailto schema test as it is not supported by fastifyURI') + } + t.same(JSON.parse(JSON.stringify(fastURI.parse(value))), expected, 'Compatibility parse: ' + value) + }) + t.end() +}) + +test('uri-js compatibility serialize', (t) => { + uriJsSerializeFixtures.forEach(([value, expected]) => { + t.same( + fastURI.serialize(value), + expected, + 'Compatibility serialize: ' + JSON.stringify(value) + ) + }) + t.end() +}) diff --git a/tools/ui/node_modules/fast-uri/test/uri-js.test.js b/tools/ui/node_modules/fast-uri/test/uri-js.test.js new file mode 100644 index 0000000000000000000000000000000000000000..109df95ea847cb4fc5e439c0f385f978b8e1072a --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/uri-js.test.js @@ -0,0 +1,912 @@ +'use strict' + +const test = require('tape') +const fastURI = require('..') + +/** + * URI.js + * + * @fileoverview An RFC 3986 compliant, scheme extendable URI parsing/normalizing/resolving/serializing library for JavaScript. + * @author Gary Court + * @see http://github.com/garycourt/uri-js + */ + +/** + * Copyright 2011 Gary Court. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, are + * permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this list of + * conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, this list + * of conditions and the following disclaimer in the documentation and/or other materials + * provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY GARY COURT ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND + * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GARY COURT OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF + * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * The views and conclusions contained in the software and documentation are those of the + * authors and should not be interpreted as representing official policies, either expressed + * or implied, of Gary Court. + */ + +test('Acquire URI', (t) => { + t.ok(fastURI) + t.end() +}) + +test('URI Parsing', (t) => { + let components + + // scheme + components = fastURI.parse('uri:') + t.equal(components.error, undefined, 'scheme errors') + t.equal(components.scheme, 'uri', 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // userinfo + components = fastURI.parse('//@') + t.equal(components.error, undefined, 'userinfo errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, '', 'userinfo') + t.equal(components.host, '', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // host + components = fastURI.parse('//') + t.equal(components.error, undefined, 'host errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // port + components = fastURI.parse('//:') + t.equal(components.error, undefined, 'port errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '', 'host') + t.equal(components.port, '', 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // path + components = fastURI.parse('') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // query + components = fastURI.parse('?') + t.equal(components.error, undefined, 'query errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, '', 'query') + t.equal(components.fragment, undefined, 'fragment') + + // fragment + components = fastURI.parse('#') + t.equal(components.error, undefined, 'fragment errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '', 'fragment') + + // fragment with character tabulation + components = fastURI.parse('#\t') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '%09', 'fragment') + + // fragment with line feed + components = fastURI.parse('#\n') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '%0A', 'fragment') + + // fragment with line tabulation + components = fastURI.parse('#\v') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '%0B', 'fragment') + + // fragment with form feed + components = fastURI.parse('#\f') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '%0C', 'fragment') + + // fragment with carriage return + components = fastURI.parse('#\r') + t.equal(components.error, undefined, 'path errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, '%0D', 'fragment') + + // all + components = fastURI.parse('uri://user:pass@example.com:123/one/two.three?q1=a1&q2=a2#body') + t.equal(components.error, undefined, 'all errors') + t.equal(components.scheme, 'uri', 'scheme') + t.equal(components.userinfo, 'user:pass', 'userinfo') + t.equal(components.host, 'example.com', 'host') + t.equal(components.port, 123, 'port') + t.equal(components.path, '/one/two.three', 'path') + t.equal(components.query, 'q1=a1&q2=a2', 'query') + t.equal(components.fragment, 'body', 'fragment') + + // IPv4address + components = fastURI.parse('//10.10.10.10') + t.equal(components.error, undefined, 'IPv4address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '10.10.10.10', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // IPv6address + components = fastURI.parse('//[2001:db8::7]') + t.equal(components.error, undefined, 'IPv4address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '2001:db8::7', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // mixed IPv4address & IPv6address + components = fastURI.parse('//[::ffff:129.144.52.38]') + t.equal(components.error, undefined, 'IPv4address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '::ffff:129.144.52.38', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // mixed IPv4address & reg-name, example from terion-name (https://github.com/garycourt/uri-js/issues/4) + components = fastURI.parse('uri://10.10.10.10.example.com/en/process') + t.equal(components.error, undefined, 'mixed errors') + t.equal(components.scheme, 'uri', 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '10.10.10.10.example.com', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '/en/process', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // IPv6address, example from bkw (https://github.com/garycourt/uri-js/pull/16) + components = fastURI.parse('//[2606:2800:220:1:248:1893:25c8:1946]/test') + t.equal(components.error, undefined, 'IPv6address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '2606:2800:220:1:248:1893:25c8:1946', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '/test', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // IPv6address, example from RFC 5952 + components = fastURI.parse('//[2001:db8::1]:80') + t.equal(components.error, undefined, 'IPv6address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '2001:db8::1', 'host') + t.equal(components.port, 80, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // IPv6address with zone identifier, RFC 6874 + components = fastURI.parse('//[fe80::a%25en1]') + t.equal(components.error, undefined, 'IPv4address errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, 'fe80::a%en1', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + // IPv6address with an unescaped interface specifier, example from pekkanikander (https://github.com/garycourt/uri-js/pull/22) + components = fastURI.parse('//[2001:db8::7%en0]') + t.equal(components.error, undefined, 'IPv6address interface errors') + t.equal(components.scheme, undefined, 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, '2001:db8::7%en0', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, '', 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + + t.end() +}) + +test('URI Serialization', (t) => { + let components = { + scheme: undefined, + userinfo: undefined, + host: undefined, + port: undefined, + path: undefined, + query: undefined, + fragment: undefined + } + t.equal(fastURI.serialize(components), '', 'Undefined Components') + + components = { + scheme: '', + userinfo: '', + host: '', + port: 0, + path: '', + query: '', + fragment: '' + } + t.equal(fastURI.serialize(components), '//@:0?#', 'Empty Components') + + components = { + scheme: 'uri', + userinfo: 'foo:bar', + host: 'example.com', + port: 1, + path: 'path', + query: 'query', + fragment: 'fragment' + } + t.equal(fastURI.serialize(components), 'uri://foo:bar@example.com:1/path?query#fragment', 'All Components') + + components = { + scheme: 'uri', + host: 'example.com', + port: '9000' + } + t.equal(fastURI.serialize(components), 'uri://example.com:9000', 'String port') + + t.equal(fastURI.serialize({ path: '//path' }), '/%2Fpath', 'Double slash path') + t.equal(fastURI.serialize({ path: 'foo:bar' }), 'foo%3Abar', 'Colon path') + t.equal(fastURI.serialize({ path: '?query' }), '%3Fquery', 'Query path') + + // mixed IPv4address & reg-name, example from terion-name (https://github.com/garycourt/uri-js/issues/4) + t.equal(fastURI.serialize({ host: '10.10.10.10.example.com' }), '//10.10.10.10.example.com', 'Mixed IPv4address & reg-name') + + // IPv6address + t.equal(fastURI.serialize({ host: '2001:db8::7' }), '//[2001:db8::7]', 'IPv6 Host') + t.equal(fastURI.serialize({ host: '::ffff:129.144.52.38' }), '//[::ffff:129.144.52.38]', 'IPv6 Mixed Host') + t.equal(fastURI.serialize({ host: '2606:2800:220:1:248:1893:25c8:1946' }), '//[2606:2800:220:1:248:1893:25c8:1946]', 'IPv6 Full Host') + + // IPv6address with zone identifier, RFC 6874 + t.equal(fastURI.serialize({ host: 'fe80::a%en1' }), '//[fe80::a%25en1]', 'IPv6 Zone Unescaped Host') + t.equal(fastURI.serialize({ host: 'fe80::a%25en1' }), '//[fe80::a%25en1]', 'IPv6 Zone Escaped Host') + + t.end() +}) + +test('URI Resolving', { skip: true }, (t) => { + // normal examples from RFC 3986 + const base = 'uri://a/b/c/d;p?q' + t.equal(fastURI.resolve(base, 'g:h'), 'g:h', 'g:h') + t.equal(fastURI.resolve(base, 'g'), 'uri://a/b/c/g', 'g') + t.equal(fastURI.resolve(base, './g'), 'uri://a/b/c/g', './g') + t.equal(fastURI.resolve(base, 'g/'), 'uri://a/b/c/g/', 'g/') + t.equal(fastURI.resolve(base, '/g'), 'uri://a/g', '/g') + t.equal(fastURI.resolve(base, '//g'), 'uri://g', '//g') + t.equal(fastURI.resolve(base, '?y'), 'uri://a/b/c/d;p?y', '?y') + t.equal(fastURI.resolve(base, 'g?y'), 'uri://a/b/c/g?y', 'g?y') + t.equal(fastURI.resolve(base, '#s'), 'uri://a/b/c/d;p?q#s', '#s') + t.equal(fastURI.resolve(base, 'g#s'), 'uri://a/b/c/g#s', 'g#s') + t.equal(fastURI.resolve(base, 'g?y#s'), 'uri://a/b/c/g?y#s', 'g?y#s') + t.equal(fastURI.resolve(base, ';x'), 'uri://a/b/c/;x', ';x') + t.equal(fastURI.resolve(base, 'g;x'), 'uri://a/b/c/g;x', 'g;x') + t.equal(fastURI.resolve(base, 'g;x?y#s'), 'uri://a/b/c/g;x?y#s', 'g;x?y#s') + t.equal(fastURI.resolve(base, ''), 'uri://a/b/c/d;p?q', '') + t.equal(fastURI.resolve(base, '.'), 'uri://a/b/c/', '.') + t.equal(fastURI.resolve(base, './'), 'uri://a/b/c/', './') + t.equal(fastURI.resolve(base, '..'), 'uri://a/b/', '..') + t.equal(fastURI.resolve(base, '../'), 'uri://a/b/', '../') + t.equal(fastURI.resolve(base, '../g'), 'uri://a/b/g', '../g') + t.equal(fastURI.resolve(base, '../..'), 'uri://a/', '../..') + t.equal(fastURI.resolve(base, '../../'), 'uri://a/', '../../') + t.equal(fastURI.resolve(base, '../../g'), 'uri://a/g', '../../g') + + // abnormal examples from RFC 3986 + t.equal(fastURI.resolve(base, '../../../g'), 'uri://a/g', '../../../g') + t.equal(fastURI.resolve(base, '../../../../g'), 'uri://a/g', '../../../../g') + + t.equal(fastURI.resolve(base, '/./g'), 'uri://a/g', '/./g') + t.equal(fastURI.resolve(base, '/../g'), 'uri://a/g', '/../g') + t.equal(fastURI.resolve(base, 'g.'), 'uri://a/b/c/g.', 'g.') + t.equal(fastURI.resolve(base, '.g'), 'uri://a/b/c/.g', '.g') + t.equal(fastURI.resolve(base, 'g..'), 'uri://a/b/c/g..', 'g..') + t.equal(fastURI.resolve(base, '..g'), 'uri://a/b/c/..g', '..g') + + t.equal(fastURI.resolve(base, './../g'), 'uri://a/b/g', './../g') + t.equal(fastURI.resolve(base, './g/.'), 'uri://a/b/c/g/', './g/.') + t.equal(fastURI.resolve(base, 'g/./h'), 'uri://a/b/c/g/h', 'g/./h') + t.equal(fastURI.resolve(base, 'g/../h'), 'uri://a/b/c/h', 'g/../h') + t.equal(fastURI.resolve(base, 'g;x=1/./y'), 'uri://a/b/c/g;x=1/y', 'g;x=1/./y') + t.equal(fastURI.resolve(base, 'g;x=1/../y'), 'uri://a/b/c/y', 'g;x=1/../y') + + t.equal(fastURI.resolve(base, 'g?y/./x'), 'uri://a/b/c/g?y/./x', 'g?y/./x') + t.equal(fastURI.resolve(base, 'g?y/../x'), 'uri://a/b/c/g?y/../x', 'g?y/../x') + t.equal(fastURI.resolve(base, 'g#s/./x'), 'uri://a/b/c/g#s/./x', 'g#s/./x') + t.equal(fastURI.resolve(base, 'g#s/../x'), 'uri://a/b/c/g#s/../x', 'g#s/../x') + + t.equal(fastURI.resolve(base, 'uri:g'), 'uri:g', 'uri:g') + t.equal(fastURI.resolve(base, 'uri:g', { tolerant: true }), 'uri://a/b/c/g', 'uri:g') + + // examples by PAEz + t.equal(fastURI.resolve('//www.g.com/', '/adf\ngf'), '//www.g.com/adf%0Agf', '/adf\\ngf') + t.equal(fastURI.resolve('//www.g.com/error\n/bleh/bleh', '..'), '//www.g.com/error%0A/', '//www.g.com/error\\n/bleh/bleh') + + t.end() +}) + +test('URI Normalizing', { skip: true }, (t) => { + // test from RFC 3987 + t.equal(fastURI.normalize('uri://www.example.org/red%09ros\xE9#red'), 'uri://www.example.org/red%09ros%C3%A9#red') + + // IPv4address + t.equal(fastURI.normalize('//192.068.001.000'), '//192.68.1.0') + + // IPv6address, example from RFC 3513 + t.equal(fastURI.normalize('http://[1080::8:800:200C:417A]/'), 'http://[1080::8:800:200c:417a]/') + + // IPv6address, examples from RFC 5952 + t.equal(fastURI.normalize('//[2001:0db8::0001]/'), '//[2001:db8::1]/') + t.equal(fastURI.normalize('//[2001:db8::1:0000:1]/'), '//[2001:db8::1:0:1]/') + t.equal(fastURI.normalize('//[2001:db8:0:0:0:0:2:1]/'), '//[2001:db8::2:1]/') + t.equal(fastURI.normalize('//[2001:db8:0:1:1:1:1:1]/'), '//[2001:db8:0:1:1:1:1:1]/') + t.equal(fastURI.normalize('//[2001:0:0:1:0:0:0:1]/'), '//[2001:0:0:1::1]/') + t.equal(fastURI.normalize('//[2001:db8:0:0:1:0:0:1]/'), '//[2001:db8::1:0:0:1]/') + t.equal(fastURI.normalize('//[2001:DB8::1]/'), '//[2001:db8::1]/') + t.equal(fastURI.normalize('//[0:0:0:0:0:ffff:192.0.2.1]/'), '//[::ffff:192.0.2.1]/') + + // Mixed IPv4 and IPv6 address + t.equal(fastURI.normalize('//[1:2:3:4:5:6:192.0.2.1]/'), '//[1:2:3:4:5:6:192.0.2.1]/') + t.equal(fastURI.normalize('//[1:2:3:4:5:6:192.068.001.000]/'), '//[1:2:3:4:5:6:192.68.1.0]/') + + t.end() +}) + +test('URI Equals', (t) => { + // test from RFC 3986 + t.equal(fastURI.equal('example://a/b/c/%7Bfoo%7D', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d'), true) + + // test from RFC 3987 + t.equal(fastURI.equal('http://example.org/~user', 'http://example.org/%7euser'), true) + + t.end() +}) + +test('Escape Component', { skip: true }, (t) => { + let chr + for (let d = 0; d <= 129; ++d) { + chr = String.fromCharCode(d) + if (!chr.match(/[$&+,;=]/)) { + t.equal(fastURI.escapeComponent(chr), encodeURIComponent(chr)) + } else { + t.equal(fastURI.escapeComponent(chr), chr) + } + } + t.equal(fastURI.escapeComponent('\u00c0'), encodeURIComponent('\u00c0')) + t.equal(fastURI.escapeComponent('\u07ff'), encodeURIComponent('\u07ff')) + t.equal(fastURI.escapeComponent('\u0800'), encodeURIComponent('\u0800')) + t.equal(fastURI.escapeComponent('\u30a2'), encodeURIComponent('\u30a2')) + t.end() +}) + +test('Unescape Component', { skip: true }, (t) => { + let chr + for (let d = 0; d <= 129; ++d) { + chr = String.fromCharCode(d) + t.equal(fastURI.unescapeComponent(encodeURIComponent(chr)), chr) + } + t.equal(fastURI.unescapeComponent(encodeURIComponent('\u00c0')), '\u00c0') + t.equal(fastURI.unescapeComponent(encodeURIComponent('\u07ff')), '\u07ff') + t.equal(fastURI.unescapeComponent(encodeURIComponent('\u0800')), '\u0800') + t.equal(fastURI.unescapeComponent(encodeURIComponent('\u30a2')), '\u30a2') + t.end() +}) + +const IRI_OPTION = { iri: true, unicodeSupport: true } + +test('IRI Parsing', { skip: true }, (t) => { + const components = fastURI.parse('uri://us\xA0er:pa\uD7FFss@example.com:123/o\uF900ne/t\uFDCFwo.t\uFDF0hree?q1=a1\uF8FF\uE000&q2=a2#bo\uFFEFdy', IRI_OPTION) + t.equal(components.error, undefined, 'all errors') + t.equal(components.scheme, 'uri', 'scheme') + t.equal(components.userinfo, 'us\xA0er:pa\uD7FFss', 'userinfo') + t.equal(components.host, 'example.com', 'host') + t.equal(components.port, 123, 'port') + t.equal(components.path, '/o\uF900ne/t\uFDCFwo.t\uFDF0hree', 'path') + t.equal(components.query, 'q1=a1\uF8FF\uE000&q2=a2', 'query') + t.equal(components.fragment, 'bo\uFFEFdy', 'fragment') + t.end() +}) + +test('IRI Serialization', { skip: true }, (t) => { + const components = { + scheme: 'uri', + userinfo: 'us\xA0er:pa\uD7FFss', + host: 'example.com', + port: 123, + path: '/o\uF900ne/t\uFDCFwo.t\uFDF0hree', + query: 'q1=a1\uF8FF\uE000&q2=a2', + fragment: 'bo\uFFEFdy\uE001' + } + t.equal(fastURI.serialize(components, IRI_OPTION), 'uri://us\xA0er:pa\uD7FFss@example.com:123/o\uF900ne/t\uFDCFwo.t\uFDF0hree?q1=a1\uF8FF\uE000&q2=a2#bo\uFFEFdy%EE%80%81') + t.end() +}) + +test('IRI Normalizing', { skip: true }, (t) => { + t.equal(fastURI.normalize('uri://www.example.org/red%09ros\xE9#red', IRI_OPTION), 'uri://www.example.org/red%09ros\xE9#red') + t.end() +}) + +test('IRI Equals', { skip: true }, (t) => { + // example from RFC 3987 + t.equal(fastURI.equal('example://a/b/c/%7Bfoo%7D/ros\xE9', 'eXAMPLE://a/./b/../b/%63/%7bfoo%7d/ros%C3%A9', IRI_OPTION), true) + t.end() +}) + +test('Convert IRI to URI', { skip: true }, (t) => { + // example from RFC 3987 + t.equal(fastURI.serialize(fastURI.parse('uri://www.example.org/red%09ros\xE9#red', IRI_OPTION)), 'uri://www.example.org/red%09ros%C3%A9#red') + + // Internationalized Domain Name conversion via punycode example from RFC 3987 + t.equal(fastURI.serialize(fastURI.parse('uri://r\xE9sum\xE9.example.org', { iri: true, domainHost: true }), { domainHost: true }), 'uri://xn--rsum-bpad.example.org') + t.end() +}) + +test('Convert URI to IRI', { skip: true }, (t) => { + // examples from RFC 3987 + t.equal(fastURI.serialize(fastURI.parse('uri://www.example.org/D%C3%BCrst'), IRI_OPTION), 'uri://www.example.org/D\xFCrst') + t.equal(fastURI.serialize(fastURI.parse('uri://www.example.org/D%FCrst'), IRI_OPTION), 'uri://www.example.org/D%FCrst') + t.equal(fastURI.serialize(fastURI.parse('uri://xn--99zt52a.example.org/%e2%80%ae'), IRI_OPTION), 'uri://xn--99zt52a.example.org/%E2%80%AE') // or uri://\u7D0D\u8C46.example.org/%E2%80%AE + + // Internationalized Domain Name conversion via punycode example from RFC 3987 + t.equal(fastURI.serialize(fastURI.parse('uri://xn--rsum-bpad.example.org', { domainHost: true }), { iri: true, domainHost: true }), 'uri://r\xE9sum\xE9.example.org') + t.end() +}) + +if (fastURI.SCHEMES.http) { + test('HTTP Equals', (t) => { + // test from RFC 2616 + t.equal(fastURI.equal('http://abc.com:80/~smith/home.html', 'http://abc.com/~smith/home.html'), true) + t.equal(fastURI.equal('http://ABC.com/%7Esmith/home.html', 'http://abc.com/~smith/home.html'), true) + t.equal(fastURI.equal('http://ABC.com:/%7esmith/home.html', 'http://abc.com/~smith/home.html'), true) + t.equal(fastURI.equal('HTTP://ABC.COM', 'http://abc.com/'), true) + // test from RFC 3986 + t.equal(fastURI.equal('http://example.com:/', 'http://example.com:80/'), true) + t.end() + }) +} + +if (fastURI.SCHEMES.https) { + test('HTTPS Equals', (t) => { + t.equal(fastURI.equal('https://example.com', 'https://example.com:443/'), true) + t.equal(fastURI.equal('https://example.com:/', 'https://example.com:443/'), true) + t.end() + }) +} + +if (fastURI.SCHEMES.urn) { + test('URN Parsing', (t) => { + // example from RFC 2141 + const components = fastURI.parse('urn:foo:a123,456') + t.equal(components.error, undefined, 'errors') + t.equal(components.scheme, 'urn', 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, undefined, 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + t.equal(components.nid, 'foo', 'nid') + t.equal(components.nss, 'a123,456', 'nss') + t.end() + }) + + test('URN Serialization', (t) => { + // example from RFC 2141 + const components = { + scheme: 'urn', + nid: 'foo', + nss: 'a123,456' + } + t.equal(fastURI.serialize(components), 'urn:foo:a123,456') + t.end() + }) + + test('URN Equals', { skip: true }, (t) => { + // test from RFC 2141 + t.equal(fastURI.equal('urn:foo:a123,456', 'urn:foo:a123,456'), true) + t.equal(fastURI.equal('urn:foo:a123,456', 'URN:foo:a123,456'), true) + t.equal(fastURI.equal('urn:foo:a123,456', 'urn:FOO:a123,456'), true) + t.equal(fastURI.equal('urn:foo:a123,456', 'urn:foo:A123,456'), false) + t.equal(fastURI.equal('urn:foo:a123%2C456', 'URN:FOO:a123%2c456'), true) + t.end() + }) + + test('URN Resolving', (t) => { + // example from epoberezkin + t.equal(fastURI.resolve('', 'urn:some:ip:prop'), 'urn:some:ip:prop') + t.equal(fastURI.resolve('#', 'urn:some:ip:prop'), 'urn:some:ip:prop') + t.equal(fastURI.resolve('urn:some:ip:prop', 'urn:some:ip:prop'), 'urn:some:ip:prop') + t.equal(fastURI.resolve('urn:some:other:prop', 'urn:some:ip:prop'), 'urn:some:ip:prop') + t.end() + }) + + test('UUID Parsing', (t) => { + // example from RFC 4122 + let components = fastURI.parse('urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6') + t.equal(components.error, undefined, 'errors') + t.equal(components.scheme, 'urn', 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, undefined, 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + t.equal(components.nid, 'uuid', 'nid') + t.equal(components.nss, undefined, 'nss') + t.equal(components.uuid, 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6', 'uuid') + + components = fastURI.parse('urn:uuid:notauuid-7dec-11d0-a765-00a0c91e6bf6') + t.notEqual(components.error, undefined, 'errors') + t.end() + }) + + test('UUID Serialization', (t) => { + // example from RFC 4122 + let components = { + scheme: 'urn', + nid: 'uuid', + uuid: 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6' + } + t.equal(fastURI.serialize(components), 'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6') + + components = { + scheme: 'urn', + nid: 'uuid', + uuid: 'notauuid-7dec-11d0-a765-00a0c91e6bf6' + } + t.equal(fastURI.serialize(components), 'urn:uuid:notauuid-7dec-11d0-a765-00a0c91e6bf6') + t.end() + }) + + test('UUID Equals', (t) => { + t.equal(fastURI.equal('URN:UUID:F81D4FAE-7DEC-11D0-A765-00A0C91E6BF6', 'urn:uuid:f81d4fae-7dec-11d0-a765-00a0c91e6bf6'), true) + t.end() + }) + + test('URN NID Override', (t) => { + let components = fastURI.parse('urn:foo:f81d4fae-7dec-11d0-a765-00a0c91e6bf6', { nid: 'uuid' }) + t.equal(components.error, undefined, 'errors') + t.equal(components.scheme, 'urn', 'scheme') + t.equal(components.path, undefined, 'path') + t.equal(components.nid, 'foo', 'nid') + t.equal(components.nss, undefined, 'nss') + t.equal(components.uuid, 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6', 'uuid') + + components = { + scheme: 'urn', + nid: 'foo', + uuid: 'f81d4fae-7dec-11d0-a765-00a0c91e6bf6' + } + t.equal(fastURI.serialize(components, { nid: 'uuid' }), 'urn:foo:f81d4fae-7dec-11d0-a765-00a0c91e6bf6') + t.end() + }) +} + +if (fastURI.SCHEMES.mailto) { + test('Mailto Parse', (t) => { + let components + + // tests from RFC 6068 + + components = fastURI.parse('mailto:chris@example.com') + t.equal(components.error, undefined, 'error') + t.equal(components.scheme, 'mailto', 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, undefined, 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, undefined, 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + t.deepEqual(components.to, ['chris@example.com'], 'to') + t.equal(components.subject, undefined, 'subject') + t.equal(components.body, undefined, 'body') + t.equal(components.headers, undefined, 'headers') + + components = fastURI.parse('mailto:infobot@example.com?subject=current-issue') + t.deepEqual(components.to, ['infobot@example.com'], 'to') + t.equal(components.subject, 'current-issue', 'subject') + + components = fastURI.parse('mailto:infobot@example.com?body=send%20current-issue') + t.deepEqual(components.to, ['infobot@example.com'], 'to') + t.equal(components.body, 'send current-issue', 'body') + + components = fastURI.parse('mailto:infobot@example.com?body=send%20current-issue%0D%0Asend%20index') + t.deepEqual(components.to, ['infobot@example.com'], 'to') + t.equal(components.body, 'send current-issue\x0D\x0Asend index', 'body') + + components = fastURI.parse('mailto:list@example.org?In-Reply-To=%3C3469A91.D10AF4C@example.com%3E') + t.deepEqual(components.to, ['list@example.org'], 'to') + t.deepEqual(components.headers, { 'In-Reply-To': '<3469A91.D10AF4C@example.com>' }, 'headers') + + components = fastURI.parse('mailto:majordomo@example.com?body=subscribe%20bamboo-l') + t.deepEqual(components.to, ['majordomo@example.com'], 'to') + t.equal(components.body, 'subscribe bamboo-l', 'body') + + components = fastURI.parse('mailto:joe@example.com?cc=bob@example.com&body=hello') + t.deepEqual(components.to, ['joe@example.com'], 'to') + t.equal(components.body, 'hello', 'body') + t.deepEqual(components.headers, { cc: 'bob@example.com' }, 'headers') + + components = fastURI.parse('mailto:joe@example.com?cc=bob@example.com?body=hello') + if (fastURI.VALIDATE_SUPPORT) t.ok(components.error, 'invalid header fields') + + components = fastURI.parse('mailto:gorby%25kremvax@example.com') + t.deepEqual(components.to, ['gorby%kremvax@example.com'], 'to gorby%kremvax@example.com') + + components = fastURI.parse('mailto:unlikely%3Faddress@example.com?blat=foop') + t.deepEqual(components.to, ['unlikely?address@example.com'], 'to unlikely?address@example.com') + t.deepEqual(components.headers, { blat: 'foop' }, 'headers') + + components = fastURI.parse('mailto:Mike%26family@example.org') + t.deepEqual(components.to, ['Mike&family@example.org'], 'to Mike&family@example.org') + + components = fastURI.parse('mailto:%22not%40me%22@example.org') + t.deepEqual(components.to, ['"not@me"@example.org'], 'to ' + '"not@me"@example.org') + + components = fastURI.parse('mailto:%22oh%5C%5Cno%22@example.org') + t.deepEqual(components.to, ['"oh\\\\no"@example.org'], 'to ' + '"oh\\\\no"@example.org') + + components = fastURI.parse("mailto:%22%5C%5C%5C%22it's%5C%20ugly%5C%5C%5C%22%22@example.org") + t.deepEqual(components.to, ['"\\\\\\"it\'s\\ ugly\\\\\\""@example.org'], 'to ' + '"\\\\\\"it\'s\\ ugly\\\\\\""@example.org') + + components = fastURI.parse('mailto:user@example.org?subject=caf%C3%A9') + t.deepEqual(components.to, ['user@example.org'], 'to') + t.equal(components.subject, 'caf\xE9', 'subject') + + components = fastURI.parse('mailto:user@example.org?subject=%3D%3Futf-8%3FQ%3Fcaf%3DC3%3DA9%3F%3D') + t.deepEqual(components.to, ['user@example.org'], 'to') + t.equal(components.subject, '=?utf-8?Q?caf=C3=A9?=', 'subject') // TODO: Verify this + + components = fastURI.parse('mailto:user@example.org?subject=%3D%3Fiso-8859-1%3FQ%3Fcaf%3DE9%3F%3D') + t.deepEqual(components.to, ['user@example.org'], 'to') + t.equal(components.subject, '=?iso-8859-1?Q?caf=E9?=', 'subject') // TODO: Verify this + + components = fastURI.parse('mailto:user@example.org?subject=caf%C3%A9&body=caf%C3%A9') + t.deepEqual(components.to, ['user@example.org'], 'to') + t.equal(components.subject, 'caf\xE9', 'subject') + t.equal(components.body, 'caf\xE9', 'body') + + if (fastURI.IRI_SUPPORT) { + components = fastURI.parse('mailto:user@%E7%B4%8D%E8%B1%86.example.org?subject=Test&body=NATTO') + t.deepEqual(components.to, ['user@xn--99zt52a.example.org'], 'to') + t.equal(components.subject, 'Test', 'subject') + t.equal(components.body, 'NATTO', 'body') + } + + t.end() + }) + + test('Mailto Serialize', (t) => { + // tests from RFC 6068 + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['chris@example.com'] }), 'mailto:chris@example.com') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['infobot@example.com'], body: 'current-issue' }), 'mailto:infobot@example.com?body=current-issue') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['infobot@example.com'], body: 'send current-issue' }), 'mailto:infobot@example.com?body=send%20current-issue') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['infobot@example.com'], body: 'send current-issue\x0D\x0Asend index' }), 'mailto:infobot@example.com?body=send%20current-issue%0D%0Asend%20index') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['list@example.org'], headers: { 'In-Reply-To': '<3469A91.D10AF4C@example.com>' } }), 'mailto:list@example.org?In-Reply-To=%3C3469A91.D10AF4C@example.com%3E') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['majordomo@example.com'], body: 'subscribe bamboo-l' }), 'mailto:majordomo@example.com?body=subscribe%20bamboo-l') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['joe@example.com'], headers: { cc: 'bob@example.com', body: 'hello' } }), 'mailto:joe@example.com?cc=bob@example.com&body=hello') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['gorby%25kremvax@example.com'] }), 'mailto:gorby%25kremvax@example.com') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['unlikely%3Faddress@example.com'], headers: { blat: 'foop' } }), 'mailto:unlikely%3Faddress@example.com?blat=foop') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['Mike&family@example.org'] }), 'mailto:Mike%26family@example.org') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['"not@me"@example.org'] }), 'mailto:%22not%40me%22@example.org') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['"oh\\\\no"@example.org'] }), 'mailto:%22oh%5C%5Cno%22@example.org') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['"\\\\\\"it\'s\\ ugly\\\\\\""@example.org'] }), "mailto:%22%5C%5C%5C%22it's%5C%20ugly%5C%5C%5C%22%22@example.org") + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['user@example.org'], subject: 'caf\xE9' }), 'mailto:user@example.org?subject=caf%C3%A9') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['user@example.org'], subject: '=?utf-8?Q?caf=C3=A9?=' }), 'mailto:user@example.org?subject=%3D%3Futf-8%3FQ%3Fcaf%3DC3%3DA9%3F%3D') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['user@example.org'], subject: '=?iso-8859-1?Q?caf=E9?=' }), 'mailto:user@example.org?subject=%3D%3Fiso-8859-1%3FQ%3Fcaf%3DE9%3F%3D') + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['user@example.org'], subject: 'caf\xE9', body: 'caf\xE9' }), 'mailto:user@example.org?subject=caf%C3%A9&body=caf%C3%A9') + if (fastURI.IRI_SUPPORT) { + t.equal(fastURI.serialize({ scheme: 'mailto', to: ['us\xE9r@\u7d0d\u8c46.example.org'], subject: 'Test', body: 'NATTO' }), 'mailto:us%C3%A9r@xn--99zt52a.example.org?subject=Test&body=NATTO') + } + t.end() + }) + + test('Mailto Equals', (t) => { + // tests from RFC 6068 + t.equal(fastURI.equal('mailto:addr1@an.example,addr2@an.example', 'mailto:?to=addr1@an.example,addr2@an.example'), true) + t.equal(fastURI.equal('mailto:?to=addr1@an.example,addr2@an.example', 'mailto:addr1@an.example?to=addr2@an.example'), true) + t.end() + }) +} + +if (fastURI.SCHEMES.ws) { + test('WS Parse', (t) => { + let components + + // example from RFC 6455, Sec 4.1 + components = fastURI.parse('ws://example.com/chat') + t.equal(components.error, undefined, 'error') + t.equal(components.scheme, 'ws', 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, 'example.com', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, undefined, 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + t.equal(components.resourceName, '/chat', 'resourceName') + t.equal(components.secure, false, 'secure') + + components = fastURI.parse('ws://example.com/foo?bar=baz') + t.equal(components.error, undefined, 'error') + t.equal(components.scheme, 'ws', 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, 'example.com', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, undefined, 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + t.equal(components.resourceName, '/foo?bar=baz', 'resourceName') + t.equal(components.secure, false, 'secure') + + components = fastURI.parse('ws://example.com/?bar=baz') + t.equal(components.resourceName, '/?bar=baz', 'resourceName') + + t.end() + }) + + test('WS Serialize', (t) => { + t.equal(fastURI.serialize({ scheme: 'ws' }), 'ws:') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com' }), 'ws://example.com') + t.equal(fastURI.serialize({ scheme: 'ws', resourceName: '/' }), 'ws:') + t.equal(fastURI.serialize({ scheme: 'ws', resourceName: '/foo' }), 'ws:/foo') + t.equal(fastURI.serialize({ scheme: 'ws', resourceName: '/foo?bar' }), 'ws:/foo?bar') + t.equal(fastURI.serialize({ scheme: 'ws', secure: false }), 'ws:') + t.equal(fastURI.serialize({ scheme: 'ws', secure: true }), 'wss:') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo' }), 'ws://example.com/foo') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar' }), 'ws://example.com/foo?bar') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', secure: false }), 'ws://example.com') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', secure: true }), 'wss://example.com') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: false }), 'ws://example.com/foo?bar') + t.equal(fastURI.serialize({ scheme: 'ws', host: 'example.com', resourceName: '/foo?bar', secure: true }), 'wss://example.com/foo?bar') + t.end() + }) + + test('WS Equal', (t) => { + t.equal(fastURI.equal('WS://ABC.COM:80/chat#one', 'ws://abc.com/chat'), true) + t.end() + }) + + test('WS Normalize', (t) => { + t.equal(fastURI.normalize('ws://example.com:80/foo#hash'), 'ws://example.com/foo') + t.end() + }) +} + +if (fastURI.SCHEMES.wss) { + test('WSS Parse', (t) => { + let components + + // example from RFC 6455, Sec 4.1 + components = fastURI.parse('wss://example.com/chat') + t.equal(components.error, undefined, 'error') + t.equal(components.scheme, 'wss', 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, 'example.com', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, undefined, 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + t.equal(components.resourceName, '/chat', 'resourceName') + t.equal(components.secure, true, 'secure') + + components = fastURI.parse('wss://example.com/foo?bar=baz') + t.equal(components.error, undefined, 'error') + t.equal(components.scheme, 'wss', 'scheme') + t.equal(components.userinfo, undefined, 'userinfo') + t.equal(components.host, 'example.com', 'host') + t.equal(components.port, undefined, 'port') + t.equal(components.path, undefined, 'path') + t.equal(components.query, undefined, 'query') + t.equal(components.fragment, undefined, 'fragment') + t.equal(components.resourceName, '/foo?bar=baz', 'resourceName') + t.equal(components.secure, true, 'secure') + + components = fastURI.parse('wss://example.com/?bar=baz') + t.equal(components.resourceName, '/?bar=baz', 'resourceName') + + t.end() + }) + + test('WSS Serialize', (t) => { + t.equal(fastURI.serialize({ scheme: 'wss' }), 'wss:') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com' }), 'wss://example.com') + t.equal(fastURI.serialize({ scheme: 'wss', resourceName: '/' }), 'wss:') + t.equal(fastURI.serialize({ scheme: 'wss', resourceName: '/foo' }), 'wss:/foo') + t.equal(fastURI.serialize({ scheme: 'wss', resourceName: '/foo?bar' }), 'wss:/foo?bar') + t.equal(fastURI.serialize({ scheme: 'wss', secure: false }), 'ws:') + t.equal(fastURI.serialize({ scheme: 'wss', secure: true }), 'wss:') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo' }), 'wss://example.com/foo') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo?bar' }), 'wss://example.com/foo?bar') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', secure: false }), 'ws://example.com') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', secure: true }), 'wss://example.com') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo?bar', secure: false }), 'ws://example.com/foo?bar') + t.equal(fastURI.serialize({ scheme: 'wss', host: 'example.com', resourceName: '/foo?bar', secure: true }), 'wss://example.com/foo?bar') + t.end() + }) + + test('WSS Equal', (t) => { + t.equal(fastURI.equal('WSS://ABC.COM:443/chat#one', 'wss://abc.com/chat'), true) + t.end() + }) + + test('WSS Normalize', (t) => { + t.equal(fastURI.normalize('wss://example.com:443/foo#hash'), 'wss://example.com/foo') + t.end() + }) +} diff --git a/tools/ui/node_modules/fast-uri/test/util.test.js b/tools/ui/node_modules/fast-uri/test/util.test.js new file mode 100644 index 0000000000000000000000000000000000000000..bbf7ebd8048b68531dce03eb828c3f6684e174c2 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/test/util.test.js @@ -0,0 +1,38 @@ +'use strict' + +const test = require('tape') +const { + stringArrayToHexStripped, + removeDotSegments +} = require('../lib/utils') + +test('stringArrayToHexStripped', (t) => { + const testCases = [ + [['0', '0', '0', '0'], ''], + [['0', '0', '0', '1'], '1'], + [['0', '0', '1', '0'], '10'], + [['0', '1', '0', '0'], '100'], + [['1', '0', '0', '0'], '1000'], + [['1', '0', '0', '1'], '1001'], + ] + + t.plan(testCases.length) + + testCases.forEach(([input, expected]) => { + t.same(stringArrayToHexStripped(input), expected) + }) +}) + +// Just fixtures, because this function already tested by resolve +test('removeDotSegments', (t) => { + const testCases = [] + // https://github.com/fastify/fast-uri/issues/139 + testCases.push(['WS:/WS://1305G130505:1&%0D:1&C(XXXXX*)))))))XXX130505:UUVUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaa13a', + 'WS:/WS://1305G130505:1&%0D:1&C(XXXXX*)))))))XXX130505:UUVUaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa$aaaaaaaaaaaa13a']) + + t.plan(testCases.length) + + testCases.forEach(([input, expected]) => { + t.same(removeDotSegments(input), expected) + }) +}) diff --git a/tools/ui/node_modules/fast-uri/tsconfig.json b/tools/ui/node_modules/fast-uri/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..9ace90de4405342d8b51cb47d020533fadfe6ab5 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/tsconfig.json @@ -0,0 +1,9 @@ +{ + "compilerOptions": { + "allowJs": true, + "checkJs": true, + "strict": true, + "noImplicitAny": true, + "target": "es2015" + } +} \ No newline at end of file diff --git a/tools/ui/node_modules/fast-uri/types/index.d.ts b/tools/ui/node_modules/fast-uri/types/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c1481ba9c3b8c99c0c1ca1893acaecf2943e46e4 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/types/index.d.ts @@ -0,0 +1,60 @@ +type FastUri = typeof fastUri + +declare namespace fastUri { + export interface URIComponent { + scheme?: string; + userinfo?: string; + host?: string; + port?: number | string; + path?: string; + query?: string; + fragment?: string; + reference?: string; + nid?: string; + nss?: string; + resourceName?: string; + secure?: boolean; + uuid?: string; + error?: string; + } + export interface Options { + scheme?: string; + reference?: string; + unicodeSupport?: boolean; + domainHost?: boolean; + absolutePath?: boolean; + tolerant?: boolean; + skipEscape?: boolean; + nid?: string; + } + + /** + * @deprecated Use Options instead + */ + export type options = Options + /** + * @deprecated Use URIComponent instead + */ + export type URIComponents = URIComponent + + export function normalize (uri: string, opts?: Options): string + export function normalize (uri: URIComponent, opts?: Options): URIComponent + export function normalize (uri: any, opts?: Options): any + + export function resolve (baseURI: string, relativeURI: string, options?: Options): string + + export function resolveComponent (base: URIComponent, relative: URIComponent, options?: Options, skipNormalization?: boolean): URIComponent + + export function parse (uri: string, opts?: Options): URIComponent + + export function serialize (component: URIComponent, opts?: Options): string + + export function equal (uriA: string, uriB: string): boolean + + export function resolve (base: string, path: string): string + + export const fastUri: FastUri + export { fastUri as default } +} + +export = fastUri diff --git a/tools/ui/node_modules/fast-uri/types/index.test-d.ts b/tools/ui/node_modules/fast-uri/types/index.test-d.ts new file mode 100644 index 0000000000000000000000000000000000000000..02670ced86048f1dab20e69266f060ded8887396 --- /dev/null +++ b/tools/ui/node_modules/fast-uri/types/index.test-d.ts @@ -0,0 +1,17 @@ +import uri, { URIComponents, URIComponent, Options, options } from '..' +import { expectDeprecated, expectType } from 'tsd' + +const parsed = uri.parse('foo') +expectType(parsed) +const parsed2 = uri.parse('foo', { + domainHost: true, + scheme: 'https', + unicodeSupport: false +}) +expectType(parsed2) + +expectType({} as URIComponents) +expectDeprecated({} as URIComponents) + +expectType({} as options) +expectDeprecated({} as options) diff --git a/tools/ui/node_modules/fdir/LICENSE b/tools/ui/node_modules/fdir/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..bb7fdee44cae62e39a6f641dddd9016f265069f7 --- /dev/null +++ b/tools/ui/node_modules/fdir/LICENSE @@ -0,0 +1,7 @@ +Copyright 2023 Abdullah Atta + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/fdir/README.md b/tools/ui/node_modules/fdir/README.md new file mode 100644 index 0000000000000000000000000000000000000000..5c70530fa063fb25cdffcc78b8588c0495e2cbb3 --- /dev/null +++ b/tools/ui/node_modules/fdir/README.md @@ -0,0 +1,91 @@ +

+ + +

The Fastest Directory Crawler & Globber for NodeJS

+

+ + + + + + + + +

+

+ +⚡ **The Fastest:** Nothing similar (in the NodeJS world) beats `fdir` in speed. It can easily crawl a directory containing **1 million files in < 1 second.** + +💡 **Stupidly Easy:** `fdir` uses expressive Builder pattern to build the crawler increasing code readability. + +🤖 **Zero Dependencies\*:** `fdir` only uses NodeJS `fs` & `path` modules. + +🕺 **Astonishingly Small:** < 2KB in size gzipped & minified. + +🖮 **Hackable:** Extending `fdir` is extremely simple now that the new Builder API is here. Feel free to experiment around. + +_\* `picomatch` must be installed manually by the user to support globbing._ + +## 🚄 Quickstart + +### Installation + +You can install using `npm`: + +```sh +$ npm i fdir +``` + +or Yarn: + +```sh +$ yarn add fdir +``` + +### Usage + +```ts +import { fdir } from "fdir"; + +// create the builder +const api = new fdir().withFullPaths().crawl("path/to/dir"); + +// get all files in a directory synchronously +const files = api.sync(); + +// or asynchronously +api.withPromise().then((files) => { + // do something with the result here. +}); +``` + +## Documentation: + +Documentation for all methods is available [here](/documentation.md). + +## 📊 Benchmarks: + +Please check the benchmark against the latest version [here](/BENCHMARKS.md). + +## 🙏Used by: + +`fdir` is downloaded over 200k+ times a week by projects around the world. Here's a list of some notable projects using `fdir` in production: + +> Note: if you think your project should be here, feel free to open an issue. Notable is anything with a considerable amount of GitHub stars. + +1. [rollup/plugins](https://github.com/rollup/plugins) +2. [SuperchupuDev/tinyglobby](https://github.com/SuperchupuDev/tinyglobby) +3. [pulumi/pulumi](https://github.com/pulumi/pulumi) +4. [dotenvx/dotenvx](https://github.com/dotenvx/dotenvx) +5. [mdn/yari](https://github.com/mdn/yari) +6. [streetwriters/notesnook](https://github.com/streetwriters/notesnook) +7. [imba/imba](https://github.com/imba/imba) +8. [moroshko/react-scanner](https://github.com/moroshko/react-scanner) +9. [netlify/build](https://github.com/netlify/build) +10. [yassinedoghri/astro-i18next](https://github.com/yassinedoghri/astro-i18next) +11. [selfrefactor/rambda](https://github.com/selfrefactor/rambda) +12. [whyboris/Video-Hub-App](https://github.com/whyboris/Video-Hub-App) + +## 🦮 LICENSE + +Copyright © 2024 Abdullah Atta under MIT. [Read full text here.](https://github.com/thecodrr/fdir/raw/master/LICENSE) diff --git a/tools/ui/node_modules/fdir/dist/index.cjs b/tools/ui/node_modules/fdir/dist/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..4868ffba35d991e03831204695d11e703a78c2d3 --- /dev/null +++ b/tools/ui/node_modules/fdir/dist/index.cjs @@ -0,0 +1,588 @@ +//#region rolldown:runtime +var __create = Object.create; +var __defProp = Object.defineProperty; +var __getOwnPropDesc = Object.getOwnPropertyDescriptor; +var __getOwnPropNames = Object.getOwnPropertyNames; +var __getProtoOf = Object.getPrototypeOf; +var __hasOwnProp = Object.prototype.hasOwnProperty; +var __copyProps = (to, from, except, desc) => { + if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) { + key = keys[i]; + if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, { + get: ((k) => from[k]).bind(null, key), + enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable + }); + } + return to; +}; +var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { + value: mod, + enumerable: true +}) : target, mod)); + +//#endregion +const path = __toESM(require("path")); +const fs = __toESM(require("fs")); + +//#region src/utils.ts +function cleanPath(path$1) { + let normalized = (0, path.normalize)(path$1); + if (normalized.length > 1 && normalized[normalized.length - 1] === path.sep) normalized = normalized.substring(0, normalized.length - 1); + return normalized; +} +const SLASHES_REGEX = /[\\/]/g; +function convertSlashes(path$1, separator) { + return path$1.replace(SLASHES_REGEX, separator); +} +const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i; +function isRootDirectory(path$1) { + return path$1 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$1); +} +function normalizePath(path$1, options) { + const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options; + const pathNeedsCleaning = process.platform === "win32" && path$1.includes("/") || path$1.startsWith("."); + if (resolvePaths) path$1 = (0, path.resolve)(path$1); + if (normalizePath$1 || pathNeedsCleaning) path$1 = cleanPath(path$1); + if (path$1 === ".") return ""; + const needsSeperator = path$1[path$1.length - 1] !== pathSeparator; + return convertSlashes(needsSeperator ? path$1 + pathSeparator : path$1, pathSeparator); +} + +//#endregion +//#region src/api/functions/join-path.ts +function joinPathWithBasePath(filename, directoryPath) { + return directoryPath + filename; +} +function joinPathWithRelativePath(root, options) { + return function(filename, directoryPath) { + const sameRoot = directoryPath.startsWith(root); + if (sameRoot) return directoryPath.slice(root.length) + filename; + else return convertSlashes((0, path.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename; + }; +} +function joinPath(filename) { + return filename; +} +function joinDirectoryPath(filename, directoryPath, separator) { + return directoryPath + filename + separator; +} +function build$7(root, options) { + const { relativePaths, includeBasePath } = options; + return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath; +} + +//#endregion +//#region src/api/functions/push-directory.ts +function pushDirectoryWithRelativePath(root) { + return function(directoryPath, paths) { + paths.push(directoryPath.substring(root.length) || "."); + }; +} +function pushDirectoryFilterWithRelativePath(root) { + return function(directoryPath, paths, filters) { + const relativePath = directoryPath.substring(root.length) || "."; + if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath); + }; +} +const pushDirectory = (directoryPath, paths) => { + paths.push(directoryPath || "."); +}; +const pushDirectoryFilter = (directoryPath, paths, filters) => { + const path$1 = directoryPath || "."; + if (filters.every((filter) => filter(path$1, true))) paths.push(path$1); +}; +const empty$2 = () => {}; +function build$6(root, options) { + const { includeDirs, filters, relativePaths } = options; + if (!includeDirs) return empty$2; + if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root); + return filters && filters.length ? pushDirectoryFilter : pushDirectory; +} + +//#endregion +//#region src/api/functions/push-file.ts +const pushFileFilterAndCount = (filename, _paths, counts, filters) => { + if (filters.every((filter) => filter(filename, false))) counts.files++; +}; +const pushFileFilter = (filename, paths, _counts, filters) => { + if (filters.every((filter) => filter(filename, false))) paths.push(filename); +}; +const pushFileCount = (_filename, _paths, counts, _filters) => { + counts.files++; +}; +const pushFile = (filename, paths) => { + paths.push(filename); +}; +const empty$1 = () => {}; +function build$5(options) { + const { excludeFiles, filters, onlyCounts } = options; + if (excludeFiles) return empty$1; + if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter; + else if (onlyCounts) return pushFileCount; + else return pushFile; +} + +//#endregion +//#region src/api/functions/get-array.ts +const getArray = (paths) => { + return paths; +}; +const getArrayGroup = () => { + return [""].slice(0, 0); +}; +function build$4(options) { + return options.group ? getArrayGroup : getArray; +} + +//#endregion +//#region src/api/functions/group-files.ts +const groupFiles = (groups, directory, files) => { + groups.push({ + directory, + files, + dir: directory + }); +}; +const empty = () => {}; +function build$3(options) { + return options.group ? groupFiles : empty; +} + +//#endregion +//#region src/api/functions/resolve-symlink.ts +const resolveSymlinksAsync = function(path$1, state, callback$1) { + const { queue, fs: fs$1, options: { suppressErrors } } = state; + queue.enqueue(); + fs$1.realpath(path$1, (error, resolvedPath) => { + if (error) return queue.dequeue(suppressErrors ? null : error, state); + fs$1.stat(resolvedPath, (error$1, stat) => { + if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state); + if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return queue.dequeue(null, state); + callback$1(stat, resolvedPath); + queue.dequeue(null, state); + }); + }); +}; +const resolveSymlinks = function(path$1, state, callback$1) { + const { queue, fs: fs$1, options: { suppressErrors } } = state; + queue.enqueue(); + try { + const resolvedPath = fs$1.realpathSync(path$1); + const stat = fs$1.statSync(resolvedPath); + if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return; + callback$1(stat, resolvedPath); + } catch (e) { + if (!suppressErrors) throw e; + } +}; +function build$2(options, isSynchronous) { + if (!options.resolveSymlinks || options.excludeSymlinks) return null; + return isSynchronous ? resolveSymlinks : resolveSymlinksAsync; +} +function isRecursive(path$1, resolved, state) { + if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state); + let parent = (0, path.dirname)(path$1); + let depth = 1; + while (parent !== state.root && depth < 2) { + const resolvedPath = state.symlinks.get(parent); + const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath)); + if (isSameRoot) depth++; + else parent = (0, path.dirname)(parent); + } + state.symlinks.set(path$1, resolved); + return depth > 1; +} +function isRecursiveUsingRealPaths(resolved, state) { + return state.visited.includes(resolved + state.options.pathSeparator); +} + +//#endregion +//#region src/api/functions/invoke-callback.ts +const onlyCountsSync = (state) => { + return state.counts; +}; +const groupsSync = (state) => { + return state.groups; +}; +const defaultSync = (state) => { + return state.paths; +}; +const limitFilesSync = (state) => { + return state.paths.slice(0, state.options.maxFiles); +}; +const onlyCountsAsync = (state, error, callback$1) => { + report(error, callback$1, state.counts, state.options.suppressErrors); + return null; +}; +const defaultAsync = (state, error, callback$1) => { + report(error, callback$1, state.paths, state.options.suppressErrors); + return null; +}; +const limitFilesAsync = (state, error, callback$1) => { + report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors); + return null; +}; +const groupsAsync = (state, error, callback$1) => { + report(error, callback$1, state.groups, state.options.suppressErrors); + return null; +}; +function report(error, callback$1, output, suppressErrors) { + if (error && !suppressErrors) callback$1(error, output); + else callback$1(null, output); +} +function build$1(options, isSynchronous) { + const { onlyCounts, group, maxFiles } = options; + if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync; + else if (group) return isSynchronous ? groupsSync : groupsAsync; + else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync; + else return isSynchronous ? defaultSync : defaultAsync; +} + +//#endregion +//#region src/api/functions/walk-directory.ts +const readdirOpts = { withFileTypes: true }; +const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => { + state.queue.enqueue(); + if (currentDepth < 0) return state.queue.dequeue(null, state); + const { fs: fs$1 } = state; + state.visited.push(crawlPath); + state.counts.directories++; + fs$1.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => { + callback$1(entries, directoryPath, currentDepth); + state.queue.dequeue(state.options.suppressErrors ? null : error, state); + }); +}; +const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => { + const { fs: fs$1 } = state; + if (currentDepth < 0) return; + state.visited.push(crawlPath); + state.counts.directories++; + let entries = []; + try { + entries = fs$1.readdirSync(crawlPath || ".", readdirOpts); + } catch (e) { + if (!state.options.suppressErrors) throw e; + } + callback$1(entries, directoryPath, currentDepth); +}; +function build(isSynchronous) { + return isSynchronous ? walkSync : walkAsync; +} + +//#endregion +//#region src/api/queue.ts +/** +* This is a custom stateless queue to track concurrent async fs calls. +* It increments a counter whenever a call is queued and decrements it +* as soon as it completes. When the counter hits 0, it calls onQueueEmpty. +*/ +var Queue = class { + count = 0; + constructor(onQueueEmpty) { + this.onQueueEmpty = onQueueEmpty; + } + enqueue() { + this.count++; + return this.count; + } + dequeue(error, output) { + if (this.onQueueEmpty && (--this.count <= 0 || error)) { + this.onQueueEmpty(error, output); + if (error) { + output.controller.abort(); + this.onQueueEmpty = void 0; + } + } + } +}; + +//#endregion +//#region src/api/counter.ts +var Counter = class { + _files = 0; + _directories = 0; + set files(num) { + this._files = num; + } + get files() { + return this._files; + } + set directories(num) { + this._directories = num; + } + get directories() { + return this._directories; + } + /** + * @deprecated use `directories` instead + */ + /* c8 ignore next 3 */ + get dirs() { + return this._directories; + } +}; + +//#endregion +//#region src/api/aborter.ts +/** +* AbortController is not supported on Node 14 so we use this until we can drop +* support for Node 14. +*/ +var Aborter = class { + aborted = false; + abort() { + this.aborted = true; + } +}; + +//#endregion +//#region src/api/walker.ts +var Walker = class { + root; + isSynchronous; + state; + joinPath; + pushDirectory; + pushFile; + getArray; + groupFiles; + resolveSymlink; + walkDirectory; + callbackInvoker; + constructor(root, options, callback$1) { + this.isSynchronous = !callback$1; + this.callbackInvoker = build$1(options, this.isSynchronous); + this.root = normalizePath(root, options); + this.state = { + root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1), + paths: [""].slice(0, 0), + groups: [], + counts: new Counter(), + options, + queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)), + symlinks: /* @__PURE__ */ new Map(), + visited: [""].slice(0, 0), + controller: new Aborter(), + fs: options.fs || fs + }; + this.joinPath = build$7(this.root, options); + this.pushDirectory = build$6(this.root, options); + this.pushFile = build$5(options); + this.getArray = build$4(options); + this.groupFiles = build$3(options); + this.resolveSymlink = build$2(options, this.isSynchronous); + this.walkDirectory = build(this.isSynchronous); + } + start() { + this.pushDirectory(this.root, this.state.paths, this.state.options.filters); + this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk); + return this.isSynchronous ? this.callbackInvoker(this.state, null) : null; + } + walk = (entries, directoryPath, depth) => { + const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state; + if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return; + const files = this.getArray(this.state.paths); + for (let i = 0; i < entries.length; ++i) { + const entry = entries[i]; + if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) { + const filename = this.joinPath(entry.name, directoryPath); + this.pushFile(filename, files, this.state.counts, filters); + } else if (entry.isDirectory()) { + let path$1 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator); + if (exclude && exclude(entry.name, path$1)) continue; + this.pushDirectory(path$1, paths, filters); + this.walkDirectory(this.state, path$1, path$1, depth - 1, this.walk); + } else if (this.resolveSymlink && entry.isSymbolicLink()) { + let path$1 = joinPathWithBasePath(entry.name, directoryPath); + this.resolveSymlink(path$1, this.state, (stat, resolvedPath) => { + if (stat.isDirectory()) { + resolvedPath = normalizePath(resolvedPath, this.state.options); + if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$1 + pathSeparator)) return; + this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$1 + pathSeparator, depth - 1, this.walk); + } else { + resolvedPath = useRealPaths ? resolvedPath : path$1; + const filename = (0, path.basename)(resolvedPath); + const directoryPath$1 = normalizePath((0, path.dirname)(resolvedPath), this.state.options); + resolvedPath = this.joinPath(filename, directoryPath$1); + this.pushFile(resolvedPath, files, this.state.counts, filters); + } + }); + } + } + this.groupFiles(this.state.groups, directoryPath, files); + }; +}; + +//#endregion +//#region src/api/async.ts +function promise(root, options) { + return new Promise((resolve$1, reject) => { + callback(root, options, (err, output) => { + if (err) return reject(err); + resolve$1(output); + }); + }); +} +function callback(root, options, callback$1) { + let walker = new Walker(root, options, callback$1); + walker.start(); +} + +//#endregion +//#region src/api/sync.ts +function sync(root, options) { + const walker = new Walker(root, options); + return walker.start(); +} + +//#endregion +//#region src/builder/api-builder.ts +var APIBuilder = class { + constructor(root, options) { + this.root = root; + this.options = options; + } + withPromise() { + return promise(this.root, this.options); + } + withCallback(cb) { + callback(this.root, this.options, cb); + } + sync() { + return sync(this.root, this.options); + } +}; + +//#endregion +//#region src/builder/index.ts +let pm = null; +/* c8 ignore next 6 */ +try { + require.resolve("picomatch"); + pm = require("picomatch"); +} catch {} +var Builder = class { + globCache = {}; + options = { + maxDepth: Infinity, + suppressErrors: true, + pathSeparator: path.sep, + filters: [] + }; + globFunction; + constructor(options) { + this.options = { + ...this.options, + ...options + }; + this.globFunction = this.options.globFunction; + } + group() { + this.options.group = true; + return this; + } + withPathSeparator(separator) { + this.options.pathSeparator = separator; + return this; + } + withBasePath() { + this.options.includeBasePath = true; + return this; + } + withRelativePaths() { + this.options.relativePaths = true; + return this; + } + withDirs() { + this.options.includeDirs = true; + return this; + } + withMaxDepth(depth) { + this.options.maxDepth = depth; + return this; + } + withMaxFiles(limit) { + this.options.maxFiles = limit; + return this; + } + withFullPaths() { + this.options.resolvePaths = true; + this.options.includeBasePath = true; + return this; + } + withErrors() { + this.options.suppressErrors = false; + return this; + } + withSymlinks({ resolvePaths = true } = {}) { + this.options.resolveSymlinks = true; + this.options.useRealPaths = resolvePaths; + return this.withFullPaths(); + } + withAbortSignal(signal) { + this.options.signal = signal; + return this; + } + normalize() { + this.options.normalizePath = true; + return this; + } + filter(predicate) { + this.options.filters.push(predicate); + return this; + } + onlyDirs() { + this.options.excludeFiles = true; + this.options.includeDirs = true; + return this; + } + exclude(predicate) { + this.options.exclude = predicate; + return this; + } + onlyCounts() { + this.options.onlyCounts = true; + return this; + } + crawl(root) { + return new APIBuilder(root || ".", this.options); + } + withGlobFunction(fn) { + this.globFunction = fn; + return this; + } + /** + * @deprecated Pass options using the constructor instead: + * ```ts + * new fdir(options).crawl("/path/to/root"); + * ``` + * This method will be removed in v7.0 + */ + /* c8 ignore next 4 */ + crawlWithOptions(root, options) { + this.options = { + ...this.options, + ...options + }; + return new APIBuilder(root || ".", this.options); + } + glob(...patterns) { + if (this.globFunction) return this.globWithOptions(patterns); + return this.globWithOptions(patterns, ...[{ dot: true }]); + } + globWithOptions(patterns, ...options) { + const globFn = this.globFunction || pm; + /* c8 ignore next 5 */ + if (!globFn) throw new Error("Please specify a glob function to use glob matching."); + var isMatch = this.globCache[patterns.join("\0")]; + if (!isMatch) { + isMatch = globFn(patterns, ...options); + this.globCache[patterns.join("\0")] = isMatch; + } + this.options.filters.push((path$1) => isMatch(path$1)); + return this; + } +}; + +//#endregion +exports.fdir = Builder; \ No newline at end of file diff --git a/tools/ui/node_modules/fdir/dist/index.d.cts b/tools/ui/node_modules/fdir/dist/index.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..f448ef5d9b563fca8360766b16cd259be4b9df5c --- /dev/null +++ b/tools/ui/node_modules/fdir/dist/index.d.cts @@ -0,0 +1,155 @@ +/// +import * as nativeFs from "fs"; +import picomatch from "picomatch"; + +//#region src/api/aborter.d.ts +/** + * AbortController is not supported on Node 14 so we use this until we can drop + * support for Node 14. + */ +declare class Aborter { + aborted: boolean; + abort(): void; +} +//#endregion +//#region src/api/queue.d.ts +type OnQueueEmptyCallback = (error: Error | null, output: WalkerState) => void; +/** + * This is a custom stateless queue to track concurrent async fs calls. + * It increments a counter whenever a call is queued and decrements it + * as soon as it completes. When the counter hits 0, it calls onQueueEmpty. + */ +declare class Queue { + private onQueueEmpty?; + count: number; + constructor(onQueueEmpty?: OnQueueEmptyCallback | undefined); + enqueue(): number; + dequeue(error: Error | null, output: WalkerState): void; +} +//#endregion +//#region src/types.d.ts +type Counts = { + files: number; + directories: number; + /** + * @deprecated use `directories` instead. Will be removed in v7.0. + */ + dirs: number; +}; +type Group = { + directory: string; + files: string[]; + /** + * @deprecated use `directory` instead. Will be removed in v7.0. + */ + dir: string; +}; +type GroupOutput = Group[]; +type OnlyCountsOutput = Counts; +type PathsOutput = string[]; +type Output = OnlyCountsOutput | PathsOutput | GroupOutput; +type FSLike = { + readdir: typeof nativeFs.readdir; + readdirSync: typeof nativeFs.readdirSync; + realpath: typeof nativeFs.realpath; + realpathSync: typeof nativeFs.realpathSync; + stat: typeof nativeFs.stat; + statSync: typeof nativeFs.statSync; +}; +type WalkerState = { + root: string; + paths: string[]; + groups: Group[]; + counts: Counts; + options: Options; + queue: Queue; + controller: Aborter; + fs: FSLike; + symlinks: Map; + visited: string[]; +}; +type ResultCallback = (error: Error | null, output: TOutput) => void; +type FilterPredicate = (path: string, isDirectory: boolean) => boolean; +type ExcludePredicate = (dirName: string, dirPath: string) => boolean; +type PathSeparator = "/" | "\\"; +type Options = { + includeBasePath?: boolean; + includeDirs?: boolean; + normalizePath?: boolean; + maxDepth: number; + maxFiles?: number; + resolvePaths?: boolean; + suppressErrors: boolean; + group?: boolean; + onlyCounts?: boolean; + filters: FilterPredicate[]; + resolveSymlinks?: boolean; + useRealPaths?: boolean; + excludeFiles?: boolean; + excludeSymlinks?: boolean; + exclude?: ExcludePredicate; + relativePaths?: boolean; + pathSeparator: PathSeparator; + signal?: AbortSignal; + globFunction?: TGlobFunction; + fs?: FSLike; +}; +type GlobMatcher = (test: string) => boolean; +type GlobFunction = (glob: string | string[], ...params: unknown[]) => GlobMatcher; +type GlobParams = T extends ((globs: string | string[], ...params: infer TParams extends unknown[]) => GlobMatcher) ? TParams : []; +//#endregion +//#region src/builder/api-builder.d.ts +declare class APIBuilder { + private readonly root; + private readonly options; + constructor(root: string, options: Options); + withPromise(): Promise; + withCallback(cb: ResultCallback): void; + sync(): TReturnType; +} +//#endregion +//#region src/builder/index.d.ts +declare class Builder { + private readonly globCache; + private options; + private globFunction?; + constructor(options?: Partial>); + group(): Builder; + withPathSeparator(separator: "/" | "\\"): this; + withBasePath(): this; + withRelativePaths(): this; + withDirs(): this; + withMaxDepth(depth: number): this; + withMaxFiles(limit: number): this; + withFullPaths(): this; + withErrors(): this; + withSymlinks({ + resolvePaths + }?: { + resolvePaths?: boolean | undefined; + }): this; + withAbortSignal(signal: AbortSignal): this; + normalize(): this; + filter(predicate: FilterPredicate): this; + onlyDirs(): this; + exclude(predicate: ExcludePredicate): this; + onlyCounts(): Builder; + crawl(root?: string): APIBuilder; + withGlobFunction(fn: TFunc): Builder; + /** + * @deprecated Pass options using the constructor instead: + * ```ts + * new fdir(options).crawl("/path/to/root"); + * ``` + * This method will be removed in v7.0 + */ + crawlWithOptions(root: string, options: Partial>): APIBuilder; + glob(...patterns: string[]): Builder; + globWithOptions(patterns: string[]): Builder; + globWithOptions(patterns: string[], ...options: GlobParams): Builder; +} +//#endregion +//#region src/index.d.ts +type Fdir = typeof Builder; +//#endregion +export { Counts, ExcludePredicate, FSLike, Fdir, FilterPredicate, GlobFunction, GlobMatcher, GlobParams, Group, GroupOutput, OnlyCountsOutput, Options, Output, PathSeparator, PathsOutput, ResultCallback, WalkerState, Builder as fdir }; \ No newline at end of file diff --git a/tools/ui/node_modules/fdir/dist/index.d.mts b/tools/ui/node_modules/fdir/dist/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..f448ef5d9b563fca8360766b16cd259be4b9df5c --- /dev/null +++ b/tools/ui/node_modules/fdir/dist/index.d.mts @@ -0,0 +1,155 @@ +/// +import * as nativeFs from "fs"; +import picomatch from "picomatch"; + +//#region src/api/aborter.d.ts +/** + * AbortController is not supported on Node 14 so we use this until we can drop + * support for Node 14. + */ +declare class Aborter { + aborted: boolean; + abort(): void; +} +//#endregion +//#region src/api/queue.d.ts +type OnQueueEmptyCallback = (error: Error | null, output: WalkerState) => void; +/** + * This is a custom stateless queue to track concurrent async fs calls. + * It increments a counter whenever a call is queued and decrements it + * as soon as it completes. When the counter hits 0, it calls onQueueEmpty. + */ +declare class Queue { + private onQueueEmpty?; + count: number; + constructor(onQueueEmpty?: OnQueueEmptyCallback | undefined); + enqueue(): number; + dequeue(error: Error | null, output: WalkerState): void; +} +//#endregion +//#region src/types.d.ts +type Counts = { + files: number; + directories: number; + /** + * @deprecated use `directories` instead. Will be removed in v7.0. + */ + dirs: number; +}; +type Group = { + directory: string; + files: string[]; + /** + * @deprecated use `directory` instead. Will be removed in v7.0. + */ + dir: string; +}; +type GroupOutput = Group[]; +type OnlyCountsOutput = Counts; +type PathsOutput = string[]; +type Output = OnlyCountsOutput | PathsOutput | GroupOutput; +type FSLike = { + readdir: typeof nativeFs.readdir; + readdirSync: typeof nativeFs.readdirSync; + realpath: typeof nativeFs.realpath; + realpathSync: typeof nativeFs.realpathSync; + stat: typeof nativeFs.stat; + statSync: typeof nativeFs.statSync; +}; +type WalkerState = { + root: string; + paths: string[]; + groups: Group[]; + counts: Counts; + options: Options; + queue: Queue; + controller: Aborter; + fs: FSLike; + symlinks: Map; + visited: string[]; +}; +type ResultCallback = (error: Error | null, output: TOutput) => void; +type FilterPredicate = (path: string, isDirectory: boolean) => boolean; +type ExcludePredicate = (dirName: string, dirPath: string) => boolean; +type PathSeparator = "/" | "\\"; +type Options = { + includeBasePath?: boolean; + includeDirs?: boolean; + normalizePath?: boolean; + maxDepth: number; + maxFiles?: number; + resolvePaths?: boolean; + suppressErrors: boolean; + group?: boolean; + onlyCounts?: boolean; + filters: FilterPredicate[]; + resolveSymlinks?: boolean; + useRealPaths?: boolean; + excludeFiles?: boolean; + excludeSymlinks?: boolean; + exclude?: ExcludePredicate; + relativePaths?: boolean; + pathSeparator: PathSeparator; + signal?: AbortSignal; + globFunction?: TGlobFunction; + fs?: FSLike; +}; +type GlobMatcher = (test: string) => boolean; +type GlobFunction = (glob: string | string[], ...params: unknown[]) => GlobMatcher; +type GlobParams = T extends ((globs: string | string[], ...params: infer TParams extends unknown[]) => GlobMatcher) ? TParams : []; +//#endregion +//#region src/builder/api-builder.d.ts +declare class APIBuilder { + private readonly root; + private readonly options; + constructor(root: string, options: Options); + withPromise(): Promise; + withCallback(cb: ResultCallback): void; + sync(): TReturnType; +} +//#endregion +//#region src/builder/index.d.ts +declare class Builder { + private readonly globCache; + private options; + private globFunction?; + constructor(options?: Partial>); + group(): Builder; + withPathSeparator(separator: "/" | "\\"): this; + withBasePath(): this; + withRelativePaths(): this; + withDirs(): this; + withMaxDepth(depth: number): this; + withMaxFiles(limit: number): this; + withFullPaths(): this; + withErrors(): this; + withSymlinks({ + resolvePaths + }?: { + resolvePaths?: boolean | undefined; + }): this; + withAbortSignal(signal: AbortSignal): this; + normalize(): this; + filter(predicate: FilterPredicate): this; + onlyDirs(): this; + exclude(predicate: ExcludePredicate): this; + onlyCounts(): Builder; + crawl(root?: string): APIBuilder; + withGlobFunction(fn: TFunc): Builder; + /** + * @deprecated Pass options using the constructor instead: + * ```ts + * new fdir(options).crawl("/path/to/root"); + * ``` + * This method will be removed in v7.0 + */ + crawlWithOptions(root: string, options: Partial>): APIBuilder; + glob(...patterns: string[]): Builder; + globWithOptions(patterns: string[]): Builder; + globWithOptions(patterns: string[], ...options: GlobParams): Builder; +} +//#endregion +//#region src/index.d.ts +type Fdir = typeof Builder; +//#endregion +export { Counts, ExcludePredicate, FSLike, Fdir, FilterPredicate, GlobFunction, GlobMatcher, GlobParams, Group, GroupOutput, OnlyCountsOutput, Options, Output, PathSeparator, PathsOutput, ResultCallback, WalkerState, Builder as fdir }; \ No newline at end of file diff --git a/tools/ui/node_modules/fdir/dist/index.mjs b/tools/ui/node_modules/fdir/dist/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..5c37e092b507dccc97d1b5a815cecceb94445698 --- /dev/null +++ b/tools/ui/node_modules/fdir/dist/index.mjs @@ -0,0 +1,570 @@ +import { createRequire } from "module"; +import { basename, dirname, normalize, relative, resolve, sep } from "path"; +import * as nativeFs from "fs"; + +//#region rolldown:runtime +var __require = /* @__PURE__ */ createRequire(import.meta.url); + +//#endregion +//#region src/utils.ts +function cleanPath(path) { + let normalized = normalize(path); + if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1); + return normalized; +} +const SLASHES_REGEX = /[\\/]/g; +function convertSlashes(path, separator) { + return path.replace(SLASHES_REGEX, separator); +} +const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i; +function isRootDirectory(path) { + return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path); +} +function normalizePath(path, options) { + const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options; + const pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith("."); + if (resolvePaths) path = resolve(path); + if (normalizePath$1 || pathNeedsCleaning) path = cleanPath(path); + if (path === ".") return ""; + const needsSeperator = path[path.length - 1] !== pathSeparator; + return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator); +} + +//#endregion +//#region src/api/functions/join-path.ts +function joinPathWithBasePath(filename, directoryPath) { + return directoryPath + filename; +} +function joinPathWithRelativePath(root, options) { + return function(filename, directoryPath) { + const sameRoot = directoryPath.startsWith(root); + if (sameRoot) return directoryPath.slice(root.length) + filename; + else return convertSlashes(relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename; + }; +} +function joinPath(filename) { + return filename; +} +function joinDirectoryPath(filename, directoryPath, separator) { + return directoryPath + filename + separator; +} +function build$7(root, options) { + const { relativePaths, includeBasePath } = options; + return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath; +} + +//#endregion +//#region src/api/functions/push-directory.ts +function pushDirectoryWithRelativePath(root) { + return function(directoryPath, paths) { + paths.push(directoryPath.substring(root.length) || "."); + }; +} +function pushDirectoryFilterWithRelativePath(root) { + return function(directoryPath, paths, filters) { + const relativePath = directoryPath.substring(root.length) || "."; + if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath); + }; +} +const pushDirectory = (directoryPath, paths) => { + paths.push(directoryPath || "."); +}; +const pushDirectoryFilter = (directoryPath, paths, filters) => { + const path = directoryPath || "."; + if (filters.every((filter) => filter(path, true))) paths.push(path); +}; +const empty$2 = () => {}; +function build$6(root, options) { + const { includeDirs, filters, relativePaths } = options; + if (!includeDirs) return empty$2; + if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root); + return filters && filters.length ? pushDirectoryFilter : pushDirectory; +} + +//#endregion +//#region src/api/functions/push-file.ts +const pushFileFilterAndCount = (filename, _paths, counts, filters) => { + if (filters.every((filter) => filter(filename, false))) counts.files++; +}; +const pushFileFilter = (filename, paths, _counts, filters) => { + if (filters.every((filter) => filter(filename, false))) paths.push(filename); +}; +const pushFileCount = (_filename, _paths, counts, _filters) => { + counts.files++; +}; +const pushFile = (filename, paths) => { + paths.push(filename); +}; +const empty$1 = () => {}; +function build$5(options) { + const { excludeFiles, filters, onlyCounts } = options; + if (excludeFiles) return empty$1; + if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter; + else if (onlyCounts) return pushFileCount; + else return pushFile; +} + +//#endregion +//#region src/api/functions/get-array.ts +const getArray = (paths) => { + return paths; +}; +const getArrayGroup = () => { + return [""].slice(0, 0); +}; +function build$4(options) { + return options.group ? getArrayGroup : getArray; +} + +//#endregion +//#region src/api/functions/group-files.ts +const groupFiles = (groups, directory, files) => { + groups.push({ + directory, + files, + dir: directory + }); +}; +const empty = () => {}; +function build$3(options) { + return options.group ? groupFiles : empty; +} + +//#endregion +//#region src/api/functions/resolve-symlink.ts +const resolveSymlinksAsync = function(path, state, callback$1) { + const { queue, fs, options: { suppressErrors } } = state; + queue.enqueue(); + fs.realpath(path, (error, resolvedPath) => { + if (error) return queue.dequeue(suppressErrors ? null : error, state); + fs.stat(resolvedPath, (error$1, stat) => { + if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state); + if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state); + callback$1(stat, resolvedPath); + queue.dequeue(null, state); + }); + }); +}; +const resolveSymlinks = function(path, state, callback$1) { + const { queue, fs, options: { suppressErrors } } = state; + queue.enqueue(); + try { + const resolvedPath = fs.realpathSync(path); + const stat = fs.statSync(resolvedPath); + if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return; + callback$1(stat, resolvedPath); + } catch (e) { + if (!suppressErrors) throw e; + } +}; +function build$2(options, isSynchronous) { + if (!options.resolveSymlinks || options.excludeSymlinks) return null; + return isSynchronous ? resolveSymlinks : resolveSymlinksAsync; +} +function isRecursive(path, resolved, state) { + if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state); + let parent = dirname(path); + let depth = 1; + while (parent !== state.root && depth < 2) { + const resolvedPath = state.symlinks.get(parent); + const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath)); + if (isSameRoot) depth++; + else parent = dirname(parent); + } + state.symlinks.set(path, resolved); + return depth > 1; +} +function isRecursiveUsingRealPaths(resolved, state) { + return state.visited.includes(resolved + state.options.pathSeparator); +} + +//#endregion +//#region src/api/functions/invoke-callback.ts +const onlyCountsSync = (state) => { + return state.counts; +}; +const groupsSync = (state) => { + return state.groups; +}; +const defaultSync = (state) => { + return state.paths; +}; +const limitFilesSync = (state) => { + return state.paths.slice(0, state.options.maxFiles); +}; +const onlyCountsAsync = (state, error, callback$1) => { + report(error, callback$1, state.counts, state.options.suppressErrors); + return null; +}; +const defaultAsync = (state, error, callback$1) => { + report(error, callback$1, state.paths, state.options.suppressErrors); + return null; +}; +const limitFilesAsync = (state, error, callback$1) => { + report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors); + return null; +}; +const groupsAsync = (state, error, callback$1) => { + report(error, callback$1, state.groups, state.options.suppressErrors); + return null; +}; +function report(error, callback$1, output, suppressErrors) { + if (error && !suppressErrors) callback$1(error, output); + else callback$1(null, output); +} +function build$1(options, isSynchronous) { + const { onlyCounts, group, maxFiles } = options; + if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync; + else if (group) return isSynchronous ? groupsSync : groupsAsync; + else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync; + else return isSynchronous ? defaultSync : defaultAsync; +} + +//#endregion +//#region src/api/functions/walk-directory.ts +const readdirOpts = { withFileTypes: true }; +const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => { + state.queue.enqueue(); + if (currentDepth < 0) return state.queue.dequeue(null, state); + const { fs } = state; + state.visited.push(crawlPath); + state.counts.directories++; + fs.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => { + callback$1(entries, directoryPath, currentDepth); + state.queue.dequeue(state.options.suppressErrors ? null : error, state); + }); +}; +const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => { + const { fs } = state; + if (currentDepth < 0) return; + state.visited.push(crawlPath); + state.counts.directories++; + let entries = []; + try { + entries = fs.readdirSync(crawlPath || ".", readdirOpts); + } catch (e) { + if (!state.options.suppressErrors) throw e; + } + callback$1(entries, directoryPath, currentDepth); +}; +function build(isSynchronous) { + return isSynchronous ? walkSync : walkAsync; +} + +//#endregion +//#region src/api/queue.ts +/** +* This is a custom stateless queue to track concurrent async fs calls. +* It increments a counter whenever a call is queued and decrements it +* as soon as it completes. When the counter hits 0, it calls onQueueEmpty. +*/ +var Queue = class { + count = 0; + constructor(onQueueEmpty) { + this.onQueueEmpty = onQueueEmpty; + } + enqueue() { + this.count++; + return this.count; + } + dequeue(error, output) { + if (this.onQueueEmpty && (--this.count <= 0 || error)) { + this.onQueueEmpty(error, output); + if (error) { + output.controller.abort(); + this.onQueueEmpty = void 0; + } + } + } +}; + +//#endregion +//#region src/api/counter.ts +var Counter = class { + _files = 0; + _directories = 0; + set files(num) { + this._files = num; + } + get files() { + return this._files; + } + set directories(num) { + this._directories = num; + } + get directories() { + return this._directories; + } + /** + * @deprecated use `directories` instead + */ + /* c8 ignore next 3 */ + get dirs() { + return this._directories; + } +}; + +//#endregion +//#region src/api/aborter.ts +/** +* AbortController is not supported on Node 14 so we use this until we can drop +* support for Node 14. +*/ +var Aborter = class { + aborted = false; + abort() { + this.aborted = true; + } +}; + +//#endregion +//#region src/api/walker.ts +var Walker = class { + root; + isSynchronous; + state; + joinPath; + pushDirectory; + pushFile; + getArray; + groupFiles; + resolveSymlink; + walkDirectory; + callbackInvoker; + constructor(root, options, callback$1) { + this.isSynchronous = !callback$1; + this.callbackInvoker = build$1(options, this.isSynchronous); + this.root = normalizePath(root, options); + this.state = { + root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1), + paths: [""].slice(0, 0), + groups: [], + counts: new Counter(), + options, + queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)), + symlinks: /* @__PURE__ */ new Map(), + visited: [""].slice(0, 0), + controller: new Aborter(), + fs: options.fs || nativeFs + }; + this.joinPath = build$7(this.root, options); + this.pushDirectory = build$6(this.root, options); + this.pushFile = build$5(options); + this.getArray = build$4(options); + this.groupFiles = build$3(options); + this.resolveSymlink = build$2(options, this.isSynchronous); + this.walkDirectory = build(this.isSynchronous); + } + start() { + this.pushDirectory(this.root, this.state.paths, this.state.options.filters); + this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk); + return this.isSynchronous ? this.callbackInvoker(this.state, null) : null; + } + walk = (entries, directoryPath, depth) => { + const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state; + if (controller.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return; + const files = this.getArray(this.state.paths); + for (let i = 0; i < entries.length; ++i) { + const entry = entries[i]; + if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) { + const filename = this.joinPath(entry.name, directoryPath); + this.pushFile(filename, files, this.state.counts, filters); + } else if (entry.isDirectory()) { + let path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator); + if (exclude && exclude(entry.name, path)) continue; + this.pushDirectory(path, paths, filters); + this.walkDirectory(this.state, path, path, depth - 1, this.walk); + } else if (this.resolveSymlink && entry.isSymbolicLink()) { + let path = joinPathWithBasePath(entry.name, directoryPath); + this.resolveSymlink(path, this.state, (stat, resolvedPath) => { + if (stat.isDirectory()) { + resolvedPath = normalizePath(resolvedPath, this.state.options); + if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return; + this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk); + } else { + resolvedPath = useRealPaths ? resolvedPath : path; + const filename = basename(resolvedPath); + const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options); + resolvedPath = this.joinPath(filename, directoryPath$1); + this.pushFile(resolvedPath, files, this.state.counts, filters); + } + }); + } + } + this.groupFiles(this.state.groups, directoryPath, files); + }; +}; + +//#endregion +//#region src/api/async.ts +function promise(root, options) { + return new Promise((resolve$1, reject) => { + callback(root, options, (err, output) => { + if (err) return reject(err); + resolve$1(output); + }); + }); +} +function callback(root, options, callback$1) { + let walker = new Walker(root, options, callback$1); + walker.start(); +} + +//#endregion +//#region src/api/sync.ts +function sync(root, options) { + const walker = new Walker(root, options); + return walker.start(); +} + +//#endregion +//#region src/builder/api-builder.ts +var APIBuilder = class { + constructor(root, options) { + this.root = root; + this.options = options; + } + withPromise() { + return promise(this.root, this.options); + } + withCallback(cb) { + callback(this.root, this.options, cb); + } + sync() { + return sync(this.root, this.options); + } +}; + +//#endregion +//#region src/builder/index.ts +let pm = null; +/* c8 ignore next 6 */ +try { + __require.resolve("picomatch"); + pm = __require("picomatch"); +} catch {} +var Builder = class { + globCache = {}; + options = { + maxDepth: Infinity, + suppressErrors: true, + pathSeparator: sep, + filters: [] + }; + globFunction; + constructor(options) { + this.options = { + ...this.options, + ...options + }; + this.globFunction = this.options.globFunction; + } + group() { + this.options.group = true; + return this; + } + withPathSeparator(separator) { + this.options.pathSeparator = separator; + return this; + } + withBasePath() { + this.options.includeBasePath = true; + return this; + } + withRelativePaths() { + this.options.relativePaths = true; + return this; + } + withDirs() { + this.options.includeDirs = true; + return this; + } + withMaxDepth(depth) { + this.options.maxDepth = depth; + return this; + } + withMaxFiles(limit) { + this.options.maxFiles = limit; + return this; + } + withFullPaths() { + this.options.resolvePaths = true; + this.options.includeBasePath = true; + return this; + } + withErrors() { + this.options.suppressErrors = false; + return this; + } + withSymlinks({ resolvePaths = true } = {}) { + this.options.resolveSymlinks = true; + this.options.useRealPaths = resolvePaths; + return this.withFullPaths(); + } + withAbortSignal(signal) { + this.options.signal = signal; + return this; + } + normalize() { + this.options.normalizePath = true; + return this; + } + filter(predicate) { + this.options.filters.push(predicate); + return this; + } + onlyDirs() { + this.options.excludeFiles = true; + this.options.includeDirs = true; + return this; + } + exclude(predicate) { + this.options.exclude = predicate; + return this; + } + onlyCounts() { + this.options.onlyCounts = true; + return this; + } + crawl(root) { + return new APIBuilder(root || ".", this.options); + } + withGlobFunction(fn) { + this.globFunction = fn; + return this; + } + /** + * @deprecated Pass options using the constructor instead: + * ```ts + * new fdir(options).crawl("/path/to/root"); + * ``` + * This method will be removed in v7.0 + */ + /* c8 ignore next 4 */ + crawlWithOptions(root, options) { + this.options = { + ...this.options, + ...options + }; + return new APIBuilder(root || ".", this.options); + } + glob(...patterns) { + if (this.globFunction) return this.globWithOptions(patterns); + return this.globWithOptions(patterns, ...[{ dot: true }]); + } + globWithOptions(patterns, ...options) { + const globFn = this.globFunction || pm; + /* c8 ignore next 5 */ + if (!globFn) throw new Error("Please specify a glob function to use glob matching."); + var isMatch = this.globCache[patterns.join("\0")]; + if (!isMatch) { + isMatch = globFn(patterns, ...options); + this.globCache[patterns.join("\0")] = isMatch; + } + this.options.filters.push((path) => isMatch(path)); + return this; + } +}; + +//#endregion +export { Builder as fdir }; \ No newline at end of file diff --git a/tools/ui/node_modules/fdir/package.json b/tools/ui/node_modules/fdir/package.json new file mode 100644 index 0000000000000000000000000000000000000000..e229dff81508001e377a1cebc22b3d81f501e7bc --- /dev/null +++ b/tools/ui/node_modules/fdir/package.json @@ -0,0 +1,103 @@ +{ + "name": "fdir", + "version": "6.5.0", + "description": "The fastest directory crawler & globbing alternative to glob, fast-glob, & tiny-glob. Crawls 1m files in < 1s", + "main": "./dist/index.cjs", + "types": "./dist/index.d.cts", + "type": "module", + "scripts": { + "prepublishOnly": "npm run test && npm run build", + "build": "tsdown", + "format": "prettier --write src __tests__ benchmarks", + "test": "vitest run __tests__/", + "test:coverage": "vitest run --coverage __tests__/", + "test:watch": "vitest __tests__/", + "bench": "ts-node benchmarks/benchmark.js", + "bench:glob": "ts-node benchmarks/glob-benchmark.ts", + "bench:fdir": "ts-node benchmarks/fdir-benchmark.ts", + "release": "./scripts/release.sh" + }, + "engines": { + "node": ">=12.0.0" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/thecodrr/fdir.git" + }, + "keywords": [ + "util", + "os", + "sys", + "fs", + "walk", + "crawler", + "directory", + "files", + "io", + "tiny-glob", + "glob", + "fast-glob", + "speed", + "javascript", + "nodejs" + ], + "author": "thecodrr ", + "license": "MIT", + "bugs": { + "url": "https://github.com/thecodrr/fdir/issues" + }, + "homepage": "https://github.com/thecodrr/fdir#readme", + "devDependencies": { + "@types/glob": "^8.1.0", + "@types/mock-fs": "^4.13.4", + "@types/node": "^20.9.4", + "@types/picomatch": "^4.0.0", + "@types/tap": "^15.0.11", + "@vitest/coverage-v8": "^0.34.6", + "all-files-in-tree": "^1.1.2", + "benny": "^3.7.1", + "csv-to-markdown-table": "^1.3.1", + "expect": "^29.7.0", + "fast-glob": "^3.3.2", + "fdir1": "npm:fdir@1.2.0", + "fdir2": "npm:fdir@2.1.0", + "fdir3": "npm:fdir@3.4.2", + "fdir4": "npm:fdir@4.1.0", + "fdir5": "npm:fdir@5.0.0", + "fs-readdir-recursive": "^1.1.0", + "get-all-files": "^4.1.0", + "glob": "^10.3.10", + "klaw-sync": "^6.0.0", + "mock-fs": "^5.2.0", + "picomatch": "^4.0.2", + "prettier": "^3.5.3", + "recur-readdir": "0.0.1", + "recursive-files": "^1.0.2", + "recursive-fs": "^2.1.0", + "recursive-readdir": "^2.2.3", + "rrdir": "^12.1.0", + "systeminformation": "^5.21.17", + "tiny-glob": "^0.2.9", + "ts-node": "^10.9.1", + "tsdown": "^0.12.5", + "typescript": "^5.3.2", + "vitest": "^0.34.6", + "walk-sync": "^3.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + }, + "module": "./dist/index.mjs", + "exports": { + ".": { + "import": "./dist/index.mjs", + "require": "./dist/index.cjs" + }, + "./package.json": "./package.json" + } +} diff --git a/tools/ui/node_modules/fflate/CHANGELOG.md b/tools/ui/node_modules/fflate/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..6e288d319905f641ca19236b012210af289dbea2 --- /dev/null +++ b/tools/ui/node_modules/fflate/CHANGELOG.md @@ -0,0 +1,125 @@ +## 0.8.3 +- Fix buffer over-read for Zip64 extra fields +- Support sync flushes (`Z_SYNC_FLUSH` in zlib) + - Allows for immediate decompression of all pushed bytes + - Enables DEFLATE stream concatenation +- Fix `zip`/`zipSync` when using cross-realm `Uint8Array` +- Improve Zip64 support for streamed or undersized archives +- Update performance estimates in README +- Fix typings for TypeScript v5.7+ +- Reduce memory consumption after compression stream completion +## 0.8.2 +- Fixed broken UMD build +- Fixed edge-case causing skipped data during streaming compression +- Fixed bug in GZIP streaming on member boundary +- Improved streaming performance on inconsistent chunk sizes +- Improved `unzip` performance on undercompressed archives +- Added flushing support into streaming API +- Added backpressure support into async streaming API + - Use new `ondrain` handler and `queuedSize` +## 0.8.1 +- Fixed reallocating on pre-supplied buffer in `inflateSync` and `unzlibSync` +- Minor documentation fixes +## 0.8.0 +- BREAKING: synchronous decompression functions now take an options object rather than an output buffer as a second parameter + - `inflateSync(compressed, outBuf)` is now `inflateSync(compressed, { out: outBuf })` +- Support dictionaries in compression and decompression +- Support multi-member files in GZIP streaming decompression +- Dramatically improved streaming performance +- Fixed missing error on certain malformed GZIP files +## 0.7.3 +- Fix folder creation for certain operating system + - Create 0-length "files" for each directory specified with "object" syntax" + - Support empty folders + - Add options for folders +- Fix minification in SWC + - Remove instanceof, no-whitespace assumptions in async functions +## 0.7.2 +- Fixed TypeScript typing for errors when using `strictNullChecks` +- Fixed failure to compress files above 64kB with `{ level: 0 }` +- Fixed AMD module definition in UMD build +## 0.7.1 +- Removed requirement for `setTimeout` +- Added support for unzip file filters (thanks to [@manucorporat](https://github.com/manucorporat): #67) +- Fixed streaming gunzip and unzlib bug causing corruption +## 0.7.0 +- Improved errors + - Now errors are error objects instead of strings + - Check the error code to apply custom logic based on error type +- Made async operations always call callbacks asynchronously +- Fixed bug that caused errors to not appear in asynchronous operations in browsers +## 0.6.10 +- Fixed async operations on Node.js with native ESM +## 0.6.5 +- Fixed streams not recognizing final chunk +- Fixed streaming UTF-8 decoder bug +## 0.6.4 +- Made streaming inflate consume all data possible +- Optimized use of values near 32-bit boundary +## 0.6.3 +- Patch exports of async functions +- Fix streaming unzip +## 0.6.2 +- Replace Adler-32 implementation (used in Zlib compression) with one more optimized for V8 + - Advice from @SheetJSDev +- Add support for extra fields, file comments in ZIP files +- Work on Rust version +## 0.6.0 +- Revamped streaming unzip for compatibility and performance improvements +- Fixed streaming data bugs +- Fixed inflation errors +- Planned new tests +## 0.5.2 +- General bugfixes +## 0.5.0 +- Add streaming zip, unzip +- Fix import issues with certain environments + - If you had problems with `worker_threads` being included in your bundle, try updating! +## 0.4.8 +- Support strict Content Security Policy + - Remove `new Function` +## 0.4.7 +- Fix data streaming bugs +## 0.4.5 +- Zip64 support + - Still not possible to have above 4GB files +## 0.4.4 +- Files up to 4GB supported + - Hey, that's better than even Node.js `zlib`! +## 0.4.1 +- Fix ZIP failure bug +- Make ZIP options work better +- Improve docs +- Fix async inflate failure +- Work on Rust version +## 0.3.11 +- Fix docs +## 0.3.9 +- Fixed issue with unzipping +## 0.3.7 +- Patched streaming compression bugs +- Added demo page +## 0.3.6 +- Allowed true ESM imports +## 0.3.4 +- Fixed rare overflow bug causing corruption +- Added async stream termination +- Added UMD bundle +## 0.3.0 +- Added support for asynchronous and synchronous streaming +- Reduced bundle size by autogenerating worker code, even in minified environments +- Error detection rather than hanging +- Improved performance +## 0.2.3 +- Improved Zlib autodetection +## 0.2.2 +- Fixed Node Worker +## 0.2.1 +- Fixed ZIP bug +## 0.2.0 +- Added support for ZIP files (parallelized) +- Added ability to terminate running asynchronous operations +## 0.1.0 +- Rewrote API: added support for asynchronous (Worker) compression/decompression, fixed critical bug involving fixed Huffman trees +## 0.0.1 +- Created, works on basic input \ No newline at end of file diff --git a/tools/ui/node_modules/fflate/LICENSE b/tools/ui/node_modules/fflate/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..bd36874f34b9ae537f2bbc383fdf6e320dfafe98 --- /dev/null +++ b/tools/ui/node_modules/fflate/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Arjun Barrett + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/tools/ui/node_modules/fflate/README.md b/tools/ui/node_modules/fflate/README.md new file mode 100644 index 0000000000000000000000000000000000000000..36e0654f28dafb8a121ed8880d6cd9e890898f4c --- /dev/null +++ b/tools/ui/node_modules/fflate/README.md @@ -0,0 +1,558 @@ +# fflate +High performance (de)compression in an 8kB package + +## Why fflate? +`fflate` (short for fast flate) is the **fastest, smallest, and most versatile** pure JavaScript compression and decompression library in existence, handily beating [`pako`](https://npmjs.com/package/pako), [`tiny-inflate`](https://npmjs.com/package/tiny-inflate), and [`UZIP.js`](https://github.com/photopea/UZIP.js) in performance benchmarks while being multiple times more lightweight. Its compression ratios are often better than even the original Zlib C library. It includes support for DEFLATE, GZIP, and Zlib data. Data compressed by `fflate` can be decompressed by other tools, and vice versa. + +In addition to the base decompression and compression APIs, `fflate` supports high-speed ZIP file archiving for an extra 3 kB. In fact, the compressor, in synchronous mode, compresses both more quickly and with a higher compression ratio than most compression software (even Info-ZIP, a C program), and in asynchronous mode it can utilize multiple threads to achieve over 3x the performance of virtually any other utility. + +| | `pako` | `tiny-inflate` | `UZIP.js` | `fflate` | +|-----------------------------|--------|------------------------|-----------------------|--------------------------------| +| Decompression performance | 1x | Up to 40% slower | **Up to 25% faster** | **Up to 25% faster** | +| Compression performance | 1x | N/A | Up to 25% faster | **Up to 50% faster** | +| Base bundle size (minified) | 45.6kB | **3kB (inflate only)** | 14.2kB | 8kB **(3kB for inflate only)** | +| Decompression support | ✅ | ✅ | ✅ | ✅ | +| Compression support | ✅ | ❌ | ✅ | ✅ | +| ZIP support | ❌ | ❌ | ✅ | ✅ | +| Streaming support | ✅ | ❌ | ❌ | ✅ | +| GZIP support | ✅ | ❌ | ❌ | ✅ | +| Supports files up to 4GB | ✅ | ❌ | ❌ | ✅ | +| Doesn't hang on error | ✅ | ❌ | ❌ | ✅ | +| Dictionary support | ✅ | ❌ | ❌ | ✅ | +| Multi-thread/Asynchronous | ❌ | ❌ | ❌ | ✅ | +| Streaming ZIP support | ❌ | ❌ | ❌ | ✅ | +| Uses ES Modules | ❌ | ❌ | ❌ | ✅ | + +## Demo +If you'd like to try `fflate` for yourself without installing it, you can take a look at the [browser demo](https://101arrowz.github.io/fflate). Since `fflate` is a pure JavaScript library, it works in both the browser and Node.js (see [Browser support](https://github.com/101arrowz/fflate/#browser-support) for more info). + +## Usage + +Install `fflate`: +```sh +npm i fflate # or yarn add fflate, or pnpm add fflate +``` + +Import: +```js +// I will assume that you use the following for the rest of this guide +import * as fflate from 'fflate'; + +// However, you should import ONLY what you need to minimize bloat. +// So, if you just need GZIP compression support: +import { gzipSync } from 'fflate'; +// Woo! You just saved 20 kB off your bundle with one line. +``` + +If your environment doesn't support ES Modules (e.g. Node.js): +```js +// Try to avoid this when using fflate in the browser, as it will import +// all of fflate's components, even those that you aren't using. +const fflate = require('fflate'); +``` + +If you want to load from a CDN in the browser: +```html + + + + + + + +``` + +If you are using Deno: +```js +// Don't use the ?dts Skypack flag; it isn't necessary for Deno support +// The @deno-types comment adds TypeScript typings + +// @deno-types="https://cdn.skypack.dev/fflate@0.8.3/lib/index.d.ts" +import * as fflate from 'https://cdn.skypack.dev/fflate@0.8.3?min'; +``` + + +If your environment doesn't support bundling: +```js +// Again, try to import just what you need + +// For the browser: +import * as fflate from 'fflate/esm/browser.js'; +// If the standard ESM import fails on Node (i.e. older version): +import * as fflate from 'fflate/esm'; +``` + +And use: +```js +// This is an ArrayBuffer of data +const massiveFileBuf = await fetch('/aMassiveFile').then( + res => res.arrayBuffer() +); +// To use fflate, you need a Uint8Array +const massiveFile = new Uint8Array(massiveFileBuf); +// Note that Node.js Buffers work just fine as well: +// const massiveFile = require('fs').readFileSync('aMassiveFile.txt'); + +// Higher level means lower performance but better compression +// The level ranges from 0 (no compression) to 9 (max compression) +// The default level is 6 +const notSoMassive = fflate.zlibSync(massiveFile, { level: 9 }); +const massiveAgain = fflate.unzlibSync(notSoMassive); +const gzipped = fflate.gzipSync(massiveFile, { + // GZIP-specific: the filename to use when decompressed + filename: 'aMassiveFile.txt', + // GZIP-specific: the modification time. Can be a Date, date string, + // or Unix timestamp + mtime: '9/1/16 2:00 PM' +}); +``` +`fflate` can autodetect a compressed file's format as well: +```js +const compressed = new Uint8Array( + await fetch('/GZIPorZLIBorDEFLATE').then(res => res.arrayBuffer()) +); +// Above example with Node.js Buffers: +// Buffer.from('H4sIAAAAAAAAE8tIzcnJBwCGphA2BQAAAA==', 'base64'); + +const decompressed = fflate.decompressSync(compressed); +``` + +Using strings is easy with `fflate`'s string conversion API: +```js +const buf = fflate.strToU8('Hello world!'); + +// The default compression method is gzip +// Increasing mem may increase performance at the cost of memory +// The mem ranges from 0 to 12, where 4 is the default +const compressed = fflate.compressSync(buf, { level: 6, mem: 8 }); + +// When you need to decompress: +const decompressed = fflate.decompressSync(compressed); +const origText = fflate.strFromU8(decompressed); +console.log(origText); // Hello world! +``` + +If you need to use an (albeit inefficient) binary string, you can set the second argument to `true`. +```js +const buf = fflate.strToU8('Hello world!'); + +// The second argument, latin1, is a boolean that indicates that the data +// is not Unicode but rather should be encoded and decoded as Latin-1. +// This is useful for creating a string from binary data that isn't +// necessarily valid UTF-8. However, binary strings are incredibly +// inefficient and tend to double file size, so they're not recommended. +const compressedString = fflate.strFromU8( + fflate.compressSync(buf), + true +); +const decompressed = fflate.decompressSync( + fflate.strToU8(compressedString, true) +); +const origText = fflate.strFromU8(decompressed); +console.log(origText); // Hello world! +``` + +You can use streams as well to incrementally add data to be compressed or decompressed: +```js +// This example uses synchronous streams, but for the best experience +// you'll definitely want to use asynchronous streams. + +let outStr = ''; +const gzipStream = new fflate.Gzip({ level: 9 }, (chunk, isLast) => { + // accumulate in an inefficient binary string (just an example) + outStr += fflate.strFromU8(chunk, true); +}); + +// You can also attach the data handler separately if you don't want to +// do so in the constructor. +gzipStream.ondata = (chunk, final) => { ... } + +// Since this is synchronous, all errors will be thrown by stream.push() +gzipStream.push(chunk1); +gzipStream.push(chunk2); + +... + +// You should mark the last chunk by using true in the second argument +// In addition to being necessary for the stream to work properly, this +// will also set the isLast parameter in the handler to true. +gzipStream.push(lastChunk, true); + +console.log(outStr); // The compressed binary string is now available + +// The options parameter for compression streams is optional; you can +// provide one parameter (the handler) or none at all if you set +// deflateStream.ondata later. +const deflateStream = new fflate.Deflate((chunk, final) => { + console.log(chunk, final); +}); + +// If you want to create a stream from strings, use EncodeUTF8 +const utfEncode = new fflate.EncodeUTF8((data, final) => { + // Chaining streams together is done by pushing to the + // next stream in the handler for the previous stream + deflateStream.push(data, final); +}); + +utfEncode.push('Hello'.repeat(1000)); +utfEncode.push(' '.repeat(100)); +utfEncode.push('world!'.repeat(10), true); + +// The deflateStream has logged the compressed data + +const inflateStream = new fflate.Inflate(); +inflateStream.ondata = (decompressedChunk, final) => { ... }; + +let stringData = ''; + +// Streaming UTF-8 decode is available too +const utfDecode = new fflate.DecodeUTF8((data, final) => { + stringData += data; +}); + +// Decompress streams auto-detect the compression method, as the +// non-streaming decompress() method does. +const dcmpStrm = new fflate.Decompress((chunk, final) => { + console.log(chunk, 'was encoded with GZIP, Zlib, or DEFLATE'); + utfDecode.push(chunk, final); +}); + +dcmpStrm.push(zlibJSONData1); +dcmpStrm.push(zlibJSONData2, true); + +// This succeeds; the UTF-8 decoder chained with the unknown compression format +// stream to reach a string as a sink. +console.log(JSON.parse(stringData)); +``` + +You can create multi-file ZIP archives easily as well. Note that by default, compression is enabled for all files, which is not useful when ZIPping many PNGs, JPEGs, PDFs, etc. because those formats are already compressed. You should either override the level on a per-file basis or globally to avoid wasting resources. +```js +// Note that the asynchronous version (see below) runs in parallel and +// is *much* (up to 3x) faster for larger archives. +const zipped = fflate.zipSync({ + // Directories can be nested structures, as in an actual filesystem + 'dir1': { + 'nested': { + // You can use Unicode in filenames + '你好.txt': fflate.strToU8('Hey there!') + }, + // You can also manually write out a directory path + 'other/tmp.txt': new Uint8Array([97, 98, 99, 100]) + }, + + // You can also provide compression options + 'massiveImage.bmp': [aMassiveFile, { + level: 9, + mem: 12 + }], + // PNG is pre-compressed; no need to waste time + 'superTinyFile.png': [aPNGFile, { level: 0 }], + + // Directories take options too + 'exec': [{ + 'hello.sh': [fflate.strToU8('echo hello world'), { + // ZIP only: Set the operating system to Unix + os: 3, + // ZIP only: Make this file executable on Unix + attrs: 0o755 << 16 + }] + }, { + // ZIP and GZIP support mtime (defaults to current time) + mtime: new Date('10/20/2020') + }] +}, { + // These options are the defaults for all files, but file-specific + // options take precedence. + level: 1, + // Obfuscate last modified time by default + mtime: new Date('1/1/1980') +}); + +// If you write the zipped data to myzip.zip and unzip, the folder +// structure will be outputted as: + +// myzip.zip (original file) +// dir1 +// |-> nested +// | |-> 你好.txt +// |-> other +// | |-> tmp.txt +// massiveImage.bmp +// superTinyFile.png + +// When decompressing, folders are not nested; all filepaths are fully +// written out in the keys. For example, the return value may be: +// { 'nested/directory/structure.txt': Uint8Array(2) [97, 97] } +const decompressed = fflate.unzipSync(zipped, { + // You may optionally supply a filter for files. By default, all files in a + // ZIP archive are extracted, but a filter can save resources by telling + // the library not to decompress certain files + filter(file) { + // Don't decompress the massive image or any files larger than 10 MiB + return file.name != 'massiveImage.bmp' && file.originalSize <= 10_000_000; + } +}); +``` + +If you need extremely high performance or custom ZIP compression formats, you can use the highly-extensible ZIP streams. They take streams as both input and output. You can even use custom compression/decompression algorithms from other libraries, as long as they [are defined in the ZIP spec](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) (see section 4.4.5). If you'd like more info on using custom compressors, [feel free to ask](https://github.com/101arrowz/fflate/discussions). +```js +// ZIP object +// Can also specify zip.ondata outside of the constructor +const zip = new fflate.Zip((err, dat, final) => { + if (!err) { + // output of the streams + console.log(dat, final); + } +}); + +const helloTxt = new fflate.ZipDeflate('hello.txt', { + level: 9 +}); + +// Always add streams to ZIP archives before pushing to those streams +zip.add(helloTxt); + +helloTxt.push(chunk1); +// Last chunk +helloTxt.push(chunk2, true); + +// ZipPassThrough is like ZipDeflate with level 0, but allows for tree shaking +const nonStreamingFile = new fflate.ZipPassThrough('test.png'); +zip.add(nonStreamingFile); +// If you have data already loaded, just .push(data, true) +nonStreamingFile.push(pngData, true); + +// You need to call .end() after finishing +// This ensures the ZIP is valid +zip.end(); + +// Unzip object +const unzipper = new fflate.Unzip(); + +// This function will almost always have to be called. It is used to support +// compression algorithms such as BZIP2 or LZMA in ZIP files if just DEFLATE +// is not enough (though it almost always is). +// If your ZIP files are not compressed, this line is not needed. +unzipper.register(fflate.UnzipInflate); + +const neededFiles = ['file1.txt', 'example.json']; + +// Can specify handler in constructor too +unzipper.onfile = file => { + // file.name is a string, file is a stream + if (neededFiles.includes(file.name)) { + file.ondata = (err, dat, final) => { + // Stream output here + console.log(dat, final); + }; + + console.log('Reading:', file.name); + + // File sizes are sometimes not set if the ZIP file did not encode + // them, so you may want to check that file.size != undefined + console.log('Compressed size', file.size); + console.log('Decompressed size', file.originalSize); + + // You should only start the stream if you plan to use it to improve + // performance. Only after starting the stream will ondata be called. + // This method will throw if the compression method hasn't been registered + file.start(); + } +}; + +// Try to keep under 5,000 files per chunk to avoid stack limit errors +// For example, if all files are a few kB, multi-megabyte chunks are OK +// If files are mostly under 100 bytes, 64kB chunks are the limit +unzipper.push(zipChunk1); +unzipper.push(zipChunk2); +unzipper.push(zipChunk3, true); +``` + +As you may have guessed, there is an asynchronous version of every method as well. Unlike most libraries, this will cause the compression or decompression run in a separate thread entirely and automatically by using Web (or Node) Workers. This means that the processing will not block the main thread at all. + +Note that there is a significant initial overhead to using workers of about 50ms for each asynchronous function. For instance, if you call `unzip` ten times, the overhead only applies for the first call, but if you call `unzip` and `zlib`, they will each cause the 50ms delay. For small (under about 50kB) payloads, the asynchronous APIs will be much slower. However, if you're compressing larger files/multiple files at once, or if the synchronous API causes the main thread to hang for too long, the callback APIs are an order of magnitude better. +```js +import { + gzip, zlib, AsyncGzip, zip, unzip, strFromU8, + Zip, AsyncZipDeflate, Unzip, AsyncUnzipInflate +} from 'fflate'; + +// Workers will work in almost any browser (even IE11!) +// All of the async APIs use a node-style callback as so: +const terminate = gzip(aMassiveFile, (err, data) => { + if (err) { + // The compressed data was likely corrupt, so we have to handle + // the error. + return; + } + // Use data however you like + console.log(data.length); +}); + +if (needToCancel) { + // The return value of any of the asynchronous APIs is a function that, + // when called, will immediately cancel the operation. The callback + // will not be called. + terminate(); +} + +// If you wish to provide options, use the second argument. + +// The consume option will render the data inside aMassiveFile unusable, +// but can improve performance and dramatically reduce memory usage. +zlib(aMassiveFile, { consume: true, level: 9 }, (err, data) => { + // Use the data +}); + +// Asynchronous streams are similar to synchronous streams, but the +// handler has the error that occurred (if any) as the first parameter, +// and they don't block the main thread. + +// Additionally, any buffers that are pushed in will be consumed and +// rendered unusable; if you need to use a buffer you push in, you +// should clone it first. +const gzs = new AsyncGzip({ level: 9, mem: 12, filename: 'hello.txt' }); +let wasCallbackCalled = false; +gzs.ondata = (err, chunk, final) => { + // Note the new err parameter + if (err) { + // Note that after this occurs, the stream becomes corrupt and must + // be discarded. You can't continue pushing chunks and expect it to + // work. + console.error(err); + return; + } + wasCallbackCalled = true; +} +gzs.push(chunk); + +// Since the stream is asynchronous, the callback will not be called +// immediately. If such behavior is absolutely necessary (it shouldn't +// be), use synchronous streams. +console.log(wasCallbackCalled) // false + +// To terminate an asynchronous stream's internal worker, call +// stream.terminate(). +gzs.terminate(); + +// This is way faster than zipSync because the compression of multiple +// files runs in parallel. In fact, the fact that it's parallelized +// makes it faster than most standalone ZIP CLIs. The effect is most +// significant for multiple large files; less so for many small ones. +zip({ f1: aMassiveFile, 'f2.txt': anotherMassiveFile }, { + // The options object is still optional, you can still do just + // zip(archive, callback) + level: 6 +}, (err, data) => { + // Save the ZIP file +}); + +// unzip is the only async function without support for consume option +// It is parallelized, so unzip is also often much faster than unzipSync +unzip(aMassiveZIPFile, (err, unzipped) => { + // If the archive has data.xml, log it here + console.log(unzipped['data.xml']); + // Conversion to string + console.log(strFromU8(unzipped['data.xml'])) +}); + +// Streaming ZIP archives can accept asynchronous streams. This automatically +// uses multicore compression. +const zip = new Zip(); +zip.ondata = (err, chunk, final) => { ... }; +// The JSON and BMP are compressed in parallel +const exampleFile = new AsyncZipDeflate('example.json'); +zip.add(exampleFile); +exampleFile.push(JSON.stringify({ large: 'object' }), true); +const exampleFile2 = new AsyncZipDeflate('example2.bmp', { level: 9 }); +zip.add(exampleFile2); +exampleFile2.push(ec2a); +exampleFile2.push(ec2b); +exampleFile2.push(ec2c); +... +exampleFile2.push(ec2Final, true); +zip.end(); + +// Streaming Unzip should register the asynchronous inflation algorithm +// for parallel processing. +const unzip = new Unzip(stream => { + if (stream.name.endsWith('.json')) { + stream.ondata = (err, chunk, final) => { ... }; + stream.start(); + + if (needToCancel) { + // To cancel these streams, call .terminate() + stream.terminate(); + } + } +}); +unzip.register(AsyncUnzipInflate); +unzip.push(data, true); +``` + +See the [documentation](https://github.com/101arrowz/fflate/blob/master/docs/README.md) for more detailed information about the API. + +## Bundle size estimates + +The bundle size measurements for `fflate` on sites like Bundlephobia include every feature of the library and should be seen as an upper bound. As long as you are using tree shaking or dead code elimination, this table should give you a general idea of `fflate`'s bundle size for the features you need. + +The maximum bundle size that is possible with `fflate` is about 33kB (12.5kB gzipped) if you use every single feature, but feature parity with `pako` is only around 10kB (as opposed to 45kB from `pako`). If your bundle size increases dramatically after adding `fflate`, please [create an issue](https://github.com/101arrowz/fflate/issues/new). + +| Feature | Bundle size (minified) | Nearest competitor | +|-------------------------|--------------------------------|-------------------------| +| Decompression | 3kB | `tiny-inflate` | +| Compression | 5kB | `UZIP.js`, 2.84x larger | +| Async decompression | 4kB (1kB + raw decompression) | N/A | +| Async compression | 6kB (1kB + raw compression) | N/A | +| ZIP decompression | 5kB (2kB + raw decompression) | `UZIP.js`, 2.84x larger | +| ZIP compression | 7kB (2kB + raw compression) | `UZIP.js`, 2.03x larger | +| GZIP/Zlib decompression | 4kB (1kB + raw decompression) | `pako`, 11.4x larger | +| GZIP/Zlib compression | 5kB (1kB + raw compression) | `pako`, 9.12x larger | +| Streaming decompression | 4kB (1kB + raw decompression) | `pako`, 11.4x larger | +| Streaming compression | 5kB (1kB + raw compression) | `pako`, 9.12x larger | + +## What makes `fflate` so fast? +Many JavaScript compression/decompression libraries exist. However, the most popular one, [`pako`](https://npmjs.com/package/pako), is merely a clone of Zlib rewritten nearly line-for-line in JavaScript. Although it is by no means poorly made, `pako` doesn't recognize the many differences between JavaScript and C, and therefore is suboptimal for performance. Moreover, even when minified, the library is 45 kB; it may not seem like much, but for anyone concerned with optimizing bundle size (especially library authors), it's more weight than necessary. + +Note that there exist some small libraries like [`tiny-inflate`](https://npmjs.com/package/tiny-inflate) for solely decompression, and with a minified size of 3 kB, it can be appealing; however, its performance is lackluster, typically 40% worse than `pako` in my tests. + +[`UZIP.js`](https://github.com/photopea/UZIP.js) is both faster (by up to 25%) and smaller (14 kB minified) than `pako`, and it contains a variety of innovations that make it excellent for both performance and compression ratio. However, the developer made a variety of tiny mistakes and inefficient design choices that make it imperfect. Moreover, it does not support GZIP or Zlib data directly; one must remove the headers manually to use `UZIP.js`. + +So what makes `fflate` different? It takes the brilliant innovations of `UZIP.js` and optimizes them while adding direct support for GZIP and Zlib data. And unlike all of the above libraries, it uses ES Modules to allow for partial builds through tree shaking, meaning that it can rival even `tiny-inflate` in size while maintaining excellent performance. The end result is a library that, in total, weighs 8kB minified for the core build (3kB for decompression only and 5kB for compression only), is about 25% faster than `UZIP.js` or up to 50% faster than `pako`, and achieves the same or better compression ratio than the rest. + +Before you decide that `fflate` is the end-all compression library, you should note that JavaScript simply cannot rival the performance of a native program. If you're only using Node.js, it's probably better to use the [native Zlib bindings](https://nodejs.org/api/zlib.html), which tend to offer the best performance. Though note that even against Zlib, `fflate` is only around 30% slower in decompression and 10% slower in compression, and can still achieve better compression ratios! + +## What about `CompressionStream`? +Like `fflate`, the [Compression Streams API](https://developer.mozilla.org/en-US/docs/Web/API/Compression_Streams_API) provides DEFLATE, GZIP, and Zlib compression and decompression support. It's a good option if you'd like to compress or decompress data without installing any third-party libraries, and it wraps native Zlib bindings to achieve better performance than what most JavaScript programs can achieve. + +However, browsers do not offer any native non-streaming compression API, and `CompressionStream` has surprisingly poor performance on data already loaded into memory; `fflate` tends to be faster even for files that are dozens of megabytes large. Similarly, `fflate` is much faster for files under a megabyte because it avoids marshalling overheads. Even when streaming hundreds of megabytes of data, the native API usually performs between 30% faster and 10% slower than `fflate`. And Compression Streams have many other disadvantages - no ability to control compression level, poor support for older browsers, no ZIP support, etc. + +If you'd still prefer to depend upon a native browser API but want to support older browsers, you can use an `fflate`-based [Compression Streams ponyfill](https://github.com/101arrowz/compression-streams-polyfill). + +## Browser support +`fflate` makes heavy use of typed arrays (`Uint8Array`, `Uint16Array`, etc.). Typed arrays can be polyfilled at the cost of performance, but the most recent browser that doesn't support them [is from 2011](https://caniuse.com/typedarrays), so I wouldn't bother. + +The asynchronous APIs also use `Worker`, which is not supported in a few browsers (however, the vast majority of browsers that support typed arrays support `Worker`). + +Other than that, `fflate` is completely ES3, meaning you probably won't even need a bundler to use it. + +## Testing +You can validate the performance of `fflate` with `npm test`. It validates that the module is working as expected, ensures the outputs are no more than 5% larger than competitors at max compression, and outputs performance metrics to `test/results`. + +Note that the time it takes for the CLI to show the completion of each test is not representative of the time each package took, so please check the JSON output if you want accurate measurements. + +## License + +This software is [MIT Licensed](./LICENSE), with special exemptions for projects +and organizations as noted below: + +- [SheetJS](https://github.com/SheetJS/) is exempt from MIT licensing and may + license any source code from this software under the BSD Zero Clause License diff --git a/tools/ui/node_modules/fflate/esm/browser.d.ts b/tools/ui/node_modules/fflate/esm/browser.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d430faf2b555c978d66c89f46155b72c2c45a971 --- /dev/null +++ b/tools/ui/node_modules/fflate/esm/browser.d.ts @@ -0,0 +1,1539 @@ +/** + * Codes for errors generated within this library + */ +export declare const FlateErrorCode: { + readonly UnexpectedEOF: 0; + readonly InvalidBlockType: 1; + readonly InvalidLengthLiteral: 2; + readonly InvalidDistance: 3; + readonly StreamFinished: 4; + readonly NoStreamHandler: 5; + readonly InvalidHeader: 6; + readonly NoCallback: 7; + readonly InvalidUTF8: 8; + readonly ExtraFieldTooLong: 9; + readonly InvalidDate: 10; + readonly FilenameTooLong: 11; + readonly StreamFinishing: 12; + readonly InvalidZipData: 13; + readonly UnknownCompressionMethod: 14; +}; +/** + * An error generated within this library + */ +export interface FlateError extends Error { + /** + * The code associated with this error + */ + code: number; +} +/** + * Options for decompressing a DEFLATE stream + */ +export interface InflateStreamOptions { + /** + * The dictionary used to compress the original data. If no dictionary was used during compression, this option has no effect. + * + * Supplying the wrong dictionary during decompression usually yields corrupt output or causes an invalid distance error. + */ + dictionary?: Uint8Array; +} +/** + * Options for decompressing DEFLATE data + */ +export interface InflateOptions extends InflateStreamOptions { + /** + * The buffer into which to write the decompressed data. Saves memory if you know the decompressed size in advance. + * + * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit. + */ + out?: Uint8Array; +} +/** + * Options for decompressing a GZIP stream + */ +export interface GunzipStreamOptions extends InflateStreamOptions { +} +/** + * Options for decompressing GZIP data + */ +export interface GunzipOptions extends InflateStreamOptions { + /** + * The buffer into which to write the decompressed data. GZIP already encodes the output size, so providing this doesn't save memory. + * + * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit. + */ + out?: Uint8Array; +} +/** + * Options for decompressing a Zlib stream + */ +export interface UnzlibStreamOptions extends InflateStreamOptions { +} +/** + * Options for decompressing Zlib data + */ +export interface UnzlibOptions extends InflateOptions { +} +/** + * Options for compressing data into a DEFLATE format + */ +export interface DeflateOptions { + /** + * The level of compression to use, ranging from 0-9. + * + * 0 will store the data without compression. + * 1 is fastest but compresses the worst, 9 is slowest but compresses the best. + * The default level is 6. + * + * Typically, binary data benefits much more from higher values than text data. + * In both cases, higher values usually take disproportionately longer than the reduction in final size that results. + * + * For example, a 1 MB text file could: + * - become 1.01 MB with level 0 in 1ms + * - become 400 kB with level 1 in 10ms + * - become 320 kB with level 9 in 100ms + */ + level?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + /** + * The memory level to use, ranging from 0-12. Increasing this increases speed and compression ratio at the cost of memory. + * + * Note that this is exponential: while level 0 uses 8 kB, level 4 uses 128 kB, level 8 uses 2 MB, and level 12 uses 32 MB. + * It is recommended not to lower the value below 4, since that tends to hurt performance. + * In addition, values above 8 tend to help very little on most data and can even hurt performance. + * + * The default value is automatically determined based on the size of the input data. + */ + mem?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12; + /** + * A buffer containing common byte sequences in the input data that can be used to significantly improve compression ratios. + * + * Dictionaries should be 32kB or smaller and include strings or byte sequences likely to appear in the input. + * The decompressor must supply the same dictionary as the compressor to extract the original data. + * + * Dictionaries only improve aggregate compression ratio when reused across multiple small inputs. They should typically not be used otherwise. + * + * Avoid using dictionaries with GZIP and ZIP to maximize software compatibility. + */ + dictionary?: Uint8Array; +} +/** + * Options for compressing data into a GZIP format + */ +export interface GzipOptions extends DeflateOptions { + /** + * When the file was last modified. Defaults to the current time. + * Set this to 0 to avoid revealing a modification date entirely. + */ + mtime?: Date | string | number; + /** + * The filename of the data. If the `gunzip` command is used to decompress the data, it will output a file + * with this name instead of the name of the compressed file. + */ + filename?: string; +} +/** + * Options for compressing data into a Zlib format + */ +export interface ZlibOptions extends DeflateOptions { +} +/** + * Handler for data (de)compression streams + * @param data The data output from the stream processor + * @param final Whether this is the final block + */ +export type FlateStreamHandler = (data: Uint8Array, final: boolean) => void; +/** + * Handler for asynchronous data (de)compression streams + * @param err Any error that occurred + * @param data The data output from the stream processor + * @param final Whether this is the final block + */ +export type AsyncFlateStreamHandler = (err: FlateError | null, data: Uint8Array, final: boolean) => void; +/** + * Handler for the asynchronous completion of (de)compression for a data chunk + * @param size The number of bytes that were processed. This is measured in terms of the input + * (i.e. compressed bytes for decompression, uncompressed bytes for compression.) + */ +export type AsyncFlateDrainHandler = (size: number) => void; +/** + * Callback for asynchronous (de)compression methods + * @param err Any error that occurred + * @param data The resulting data. Only present if `err` is null + */ +export type FlateCallback = (err: FlateError | null, data: Uint8Array) => void; +interface AsyncOptions { + /** + * Whether or not to "consume" the source data. This will make the typed array/buffer you pass in + * unusable but will increase performance and reduce memory usage. + */ + consume?: boolean; +} +/** + * Options for compressing data asynchronously into a DEFLATE format + */ +export interface AsyncDeflateOptions extends DeflateOptions, AsyncOptions { +} +/** + * Options for decompressing DEFLATE data asynchronously + */ +export interface AsyncInflateOptions extends AsyncOptions, InflateStreamOptions { + /** + * The original size of the data. Currently, the asynchronous API disallows + * writing into a buffer you provide; the best you can do is provide the + * size in bytes and be given back a new typed array. + */ + size?: number; +} +/** + * Options for compressing data asynchronously into a GZIP format + */ +export interface AsyncGzipOptions extends GzipOptions, AsyncOptions { +} +/** + * Options for decompressing GZIP data asynchronously + */ +export interface AsyncGunzipOptions extends AsyncOptions, InflateStreamOptions { +} +/** + * Options for compressing data asynchronously into a Zlib format + */ +export interface AsyncZlibOptions extends ZlibOptions, AsyncOptions { +} +/** + * Options for decompressing Zlib data asynchronously + */ +export interface AsyncUnzlibOptions extends AsyncInflateOptions { +} +/** + * A terminable compression/decompression process + */ +export interface AsyncTerminable { + /** + * Terminates the worker thread immediately. The callback will not be called. + */ + (): void; +} +/** + * Streaming DEFLATE compression + */ +export declare class Deflate { + /** + * Creates a DEFLATE stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: DeflateOptions, cb?: FlateStreamHandler); + /** + * Creates a DEFLATE stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + private b; + private s; + private o; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + private p; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE compression + */ +export declare class AsyncDeflate { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous DEFLATE stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: DeflateOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous DEFLATE stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function deflate(data: Uint8Array, opts: AsyncDeflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param cb The function to be called upon compression completion + */ +export declare function deflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @returns The deflated version of the data + */ +export declare function deflateSync(data: Uint8Array, opts?: DeflateOptions): Uint8Array; +/** + * Streaming DEFLATE decompression + */ +export declare class Inflate { + private s; + private o; + private p; + private d; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a DEFLATE decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: InflateStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a DEFLATE decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + private e; + private c; + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the final chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE decompression + */ +export declare class AsyncInflate { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous DEFLATE decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: InflateStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous DEFLATE decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function inflate(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function inflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands DEFLATE data with no wrapper + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function inflateSync(data: Uint8Array): Uint8Array; +/** + * Expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function inflateSync(data: Uint8Array, opts?: InflateOptions): Uint8Array; +/** + * Streaming GZIP compression + */ +export declare class Gzip { + private c; + private l; + private v; + private o; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a GZIP stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: GzipOptions, cb?: FlateStreamHandler); + /** + * Creates a GZIP stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + private p; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming GZIP compression + */ +export declare class AsyncGzip { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous GZIP stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: GzipOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous GZIP stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function gzip(data: Uint8Array, opts: AsyncGzipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with GZIP + * @param data The data to compress + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @returns The gzipped version of the data + */ +export declare function gzipSync(data: Uint8Array, opts?: GzipOptions): Uint8Array; +/** + * Handler for new GZIP members in concatenated GZIP streams. Useful for building indices used to perform random-access reads on compressed files. + * @param offset The offset of the new member relative to the start of the stream + */ +export type GunzipMemberHandler = (offset: number) => void; +/** + * Streaming single or multi-member GZIP decompression + */ +export declare class Gunzip { + private v; + private r; + private o; + private p; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * The handler to call whenever a new GZIP member is found + */ + onmember?: GunzipMemberHandler; + /** + * Creates a GUNZIP stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: GunzipStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a GUNZIP stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming single or multi-member GZIP decompression + */ +export declare class AsyncGunzip { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * The handler to call whenever a new GZIP member is found + */ + onmember?: GunzipMemberHandler; + /** + * Creates an asynchronous GUNZIP stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: GunzipStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous GUNZIP stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands GZIP data + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gunzip(data: Uint8Array, opts: AsyncGunzipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands GZIP data + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gunzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands GZIP data + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function gunzipSync(data: Uint8Array): Uint8Array; +/** + * Expands GZIP data + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function gunzipSync(data: Uint8Array, opts?: GunzipOptions): Uint8Array; +/** + * Streaming Zlib compression + */ +export declare class Zlib { + private c; + private v; + private o; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a Zlib stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: ZlibOptions, cb?: FlateStreamHandler); + /** + * Creates a Zlib stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be zlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + private p; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming Zlib compression + */ +export declare class AsyncZlib { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous Zlib stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: ZlibOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous Zlib stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with Zlib + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + */ +export declare function zlib(data: Uint8Array, opts: AsyncZlibOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with Zlib + * @param data The data to compress + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compress data with Zlib + * @param data The data to compress + * @param opts The compression options + * @returns The zlib-compressed version of the data + */ +export declare function zlibSync(data: Uint8Array, opts?: ZlibOptions): Uint8Array; +/** + * Streaming Zlib decompression + */ +export declare class Unzlib { + private v; + private p; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a Zlib decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: UnzlibStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a Zlib decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be unzlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming Zlib decompression + */ +export declare class AsyncUnzlib { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous Zlib decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: UnzlibStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous Zlib decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be decompressed from Zlib + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands Zlib data + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function unzlib(data: Uint8Array, opts: AsyncUnzlibOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands Zlib data + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function unzlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands Zlib data + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function unzlibSync(data: Uint8Array): Uint8Array; +/** + * Expands Zlib data + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function unzlibSync(data: Uint8Array, opts?: UnzlibOptions): Uint8Array; +export { gzip as compress, AsyncGzip as AsyncCompress }; +export { gzipSync as compressSync, Gzip as Compress }; +/** + * Streaming GZIP, Zlib, or raw DEFLATE decompression + */ +export declare class Decompress { + private G; + private I; + private Z; + private o; + private s; + private p; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is decompressed + */ + constructor(opts: InflateStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a decompression stream + * @param cb The callback to call whenever data is decompressed + */ + constructor(cb?: FlateStreamHandler); + private i; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression + */ +export declare class AsyncDecompress { + private G; + private I; + private Z; + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is decompressed + */ + constructor(opts: InflateStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous decompression stream + * @param cb The callback to call whenever data is decompressed + */ + constructor(cb?: AsyncFlateStreamHandler); + private i; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function decompress(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function decompress(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function decompressSync(data: Uint8Array, opts?: InflateOptions): Uint8Array; +/** + * Attributes for files added to a ZIP archive object + */ +export interface ZipAttributes { + /** + * The operating system of origin for this file. The value is defined + * by PKZIP's APPNOTE.txt, section 4.4.2.2. For example, 0 (the default) + * is MS/DOS, 3 is Unix, 19 is macOS. + */ + os?: number; + /** + * The file's attributes. These are traditionally somewhat complicated + * and platform-dependent, so using them is scarcely necessary. However, + * here is a representation of what this is, bit by bit: + * + * `TTTTugtrwxrwxrwx0000000000ADVSHR` + * + * TTTT = file type (rarely useful) + * + * u = setuid, g = setgid, t = sticky + * + * rwx = user permissions, rwx = group permissions, rwx = other permissions + * + * 0000000000 = unused + * + * A = archive, D = directory, V = volume label, S = system file, H = hidden, R = read-only + * + * If you want to set the Unix permissions, for instance, just bit shift by 16, e.g. 0o644 << 16. + * Note that attributes usually only work in conjunction with the `os` setting: you must use + * `os` = 3 (Unix) if you want to set Unix permissions + */ + attrs?: number; + /** + * Extra metadata to add to the file. This field is defined by PKZIP's APPNOTE.txt, + * section 4.4.28. At most 65,535 bytes may be used in each ID. The ID must be an + * integer between 0 and 65,535, inclusive. + * + * This field is incredibly rare and almost never needed except for compliance with + * proprietary standards and software. + */ + extra?: Record; + /** + * The comment to attach to the file. This field is defined by PKZIP's APPNOTE.txt, + * section 4.4.26. The comment must be at most 65,535 bytes long UTF-8 encoded. This + * field is not read by consumer software. + */ + comment?: string; + /** + * When the file was last modified. Defaults to the current time. + */ + mtime?: GzipOptions['mtime']; +} +/** + * Options for creating a ZIP archive + */ +export interface ZipOptions extends DeflateOptions, ZipAttributes { +} +/** + * Options for expanding a ZIP archive + */ +export interface UnzipOptions { + /** + * A filter function to extract only certain files from a ZIP archive + */ + filter?: UnzipFileFilter; +} +/** + * Options for asynchronously creating a ZIP archive + */ +export interface AsyncZipOptions extends AsyncDeflateOptions, ZipAttributes { +} +/** + * Options for asynchronously expanding a ZIP archive + */ +export interface AsyncUnzipOptions extends UnzipOptions { +} +/** + * A file that can be used to create a ZIP archive + */ +export type ZippableFile = Uint8Array | Zippable | [Uint8Array | Zippable, ZipOptions]; +/** + * A file that can be used to asynchronously create a ZIP archive + */ +export type AsyncZippableFile = Uint8Array | AsyncZippable | [Uint8Array | AsyncZippable, AsyncZipOptions]; +/** + * The complete directory structure of a ZIPpable archive + */ +export interface Zippable { + [path: string]: ZippableFile; +} +/** + * The complete directory structure of an asynchronously ZIPpable archive + */ +export interface AsyncZippable { + [path: string]: AsyncZippableFile; +} +/** + * An unzipped archive. The full path of each file is used as the key, + * and the file is the value + */ +export interface Unzipped { + [path: string]: Uint8Array; +} +/** + * Handler for string generation streams + * @param data The string output from the stream processor + * @param final Whether this is the final block + */ +export type StringStreamHandler = (data: string, final: boolean) => void; +/** + * Callback for asynchronous ZIP decompression + * @param err Any error that occurred + * @param data The decompressed ZIP archive + */ +export type UnzipCallback = (err: FlateError | null, data: Unzipped) => void; +/** + * Handler for streaming ZIP decompression + * @param file The file that was found in the archive + */ +export type UnzipFileHandler = (file: UnzipFile) => void; +/** + * Streaming UTF-8 decoding + */ +export declare class DecodeUTF8 { + private p; + private t; + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is decoded + */ + constructor(cb?: StringStreamHandler); + /** + * Pushes a chunk to be decoded from UTF-8 binary + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * The handler to call whenever data is available + */ + ondata: StringStreamHandler; +} +/** + * Streaming UTF-8 encoding + */ +export declare class EncodeUTF8 { + private d; + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is encoded + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be encoded to UTF-8 + * @param chunk The string data to push + * @param final Whether this is the last chunk + */ + push(chunk: string, final?: boolean): void; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; +} +/** + * Converts a string into a Uint8Array for use with compression/decompression methods + * @param str The string to encode + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless decoding a binary string. + * @returns The string encoded in UTF-8/Latin-1 binary + */ +export declare function strToU8(str: string, latin1?: boolean): Uint8Array; +/** + * Converts a Uint8Array to a string + * @param dat The data to decode to string + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless encoding to binary string. + * @returns The original UTF-8/Latin-1 string + */ +export declare function strFromU8(dat: Uint8Array, latin1?: boolean): string; +/** + * A stream that can be used to create a file in a ZIP archive + */ +export interface ZipInputFile extends ZipAttributes { + /** + * The filename to associate with the data provided to this stream. If you + * want a file in a subdirectory, use forward slashes as a separator (e.g. + * `directory/filename.ext`). This will still work on Windows. + */ + filename: string; + /** + * The size of the file in bytes. This attribute may be invalid after + * the file is added to the ZIP archive; it must be correct only before the + * stream completes. + * + * If you don't want to have to compute this yourself, consider extending the + * ZipPassThrough class and overriding its process() method, or using one of + * ZipDeflate or AsyncZipDeflate. + */ + size: number; + /** + * A CRC of the original file contents. This attribute may be invalid after + * the file is added to the ZIP archive; it must be correct only before the + * stream completes. + * + * If you don't want to have to generate this yourself, consider extending the + * ZipPassThrough class and overriding its process() method, or using one of + * ZipDeflate or AsyncZipDeflate. + */ + crc: number; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA + */ + compression: number; + /** + * Bits 1 and 2 of the general purpose bit flag, specified in PKZIP's + * APPNOTE.txt, section 4.4.4. Should be between 0 and 3. This is unlikely + * to be necessary. + */ + flag?: number; + /** + * The handler to be called when data is added. After passing this stream to + * the ZIP file object, this handler will always be defined. To call it: + * + * `stream.ondata(error, chunk, final)` + * + * error = any error that occurred (null if there was no error) + * + * chunk = a Uint8Array of the data that was added (null if there was an + * error) + * + * final = boolean, whether this is the final chunk in the stream + */ + ondata?: AsyncFlateStreamHandler; + /** + * A method called when the stream is no longer needed, for clean-up + * purposes. This will not always be called after the stream completes, + * so you may wish to call this.terminate() after the final chunk is + * processed if you have clean-up logic. + */ + terminate?: AsyncTerminable; +} +/** + * A pass-through stream to keep data uncompressed in a ZIP archive. + */ +export declare class ZipPassThrough implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private c; + /** + * Creates a pass-through stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + */ + constructor(filename: string); + /** + * Processes a chunk and pushes to the output stream. You can override this + * method in a subclass for custom behavior, but by default this passes + * the data through. You must call this.ondata(err, chunk, final) at some + * point in this method. + * @param chunk The chunk to process + * @param final Whether this is the last chunk + */ + protected process(chunk: Uint8Array, final: boolean): void; + /** + * Pushes a chunk to be added. If you are subclassing this with a custom + * compression algorithm, note that you must push data from the source + * file only, pre-compression. + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate + * for better performance + */ +export declare class ZipDeflate implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + flag: 0 | 1 | 2 | 3; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private d; + /** + * Creates a DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + constructor(filename: string, opts?: DeflateOptions); + private process; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE compression for ZIP archives + */ +export declare class AsyncZipDeflate implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + flag: 0 | 1 | 2 | 3; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private d; + terminate: AsyncTerminable; + /** + * Creates an asynchronous DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + constructor(filename: string, opts?: DeflateOptions); + private process; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * A zippable archive to which files can incrementally be added + */ +export declare class Zip { + private u; + private d; + /** + * Creates an empty ZIP archive to which files can be added + * @param cb The callback to call whenever data for the generated ZIP archive + * is available + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Adds a file to the ZIP archive + * @param file The file stream to add + */ + add(file: ZipInputFile): void; + /** + * Ends the process of adding files and prepares to emit the final chunks. + * This *must* be called after adding all desired files for the resulting + * ZIP file to work properly. + */ + end(): void; + private e; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to add() will fail. + */ + terminate(): void; + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; +} +/** + * Asynchronously creates a ZIP file + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @param cb The callback to call with the generated ZIP archive + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zip(data: AsyncZippable, opts: AsyncZipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously creates a ZIP file + * @param data The directory structure for the ZIP archive + * @param cb The callback to call with the generated ZIP archive + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zip(data: AsyncZippable, cb: FlateCallback): AsyncTerminable; +/** + * Synchronously creates a ZIP file. Prefer using `zip` for better performance + * with more than one file. + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @returns The generated ZIP archive + */ +export declare function zipSync(data: Zippable, opts?: ZipOptions): Uint8Array; +/** + * A decoder for files in ZIP streams + */ +export interface UnzipDecoder { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * Pushes a chunk to be decompressed + * @param chunk The data in this chunk. Do not consume (detach) this buffer. + * @param final Whether this is the last chunk in the data stream + */ + push(chunk: Uint8Array, final: boolean): void; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to push() should silently fail. + */ + terminate?: AsyncTerminable; +} +/** + * A constructor for a decoder for unzip streams + */ +export interface UnzipDecoderConstructor { + /** + * Creates an instance of the decoder + * @param filename The name of the file + * @param size The compressed size of the file + * @param originalSize The original size of the file + */ + new (filename: string, size?: number, originalSize?: number): UnzipDecoder; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA + */ + compression: number; +} +/** + * Information about a file to be extracted from a ZIP archive + */ +export interface UnzipFileInfo { + /** + * The name of the file + */ + name: string; + /** + * The compressed size of the file + */ + size: number; + /** + * The original size of the file + */ + originalSize: number; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA. If the filter function returns true + * but this value is not 8, the unzip function will throw. + */ + compression: number; +} +/** + * A filter for files to be extracted during the unzipping process + * @param file The info for the current file being processed + * @returns Whether or not to extract the current file + */ +export type UnzipFileFilter = (file: UnzipFileInfo) => boolean; +/** + * Streaming file extraction from ZIP archives + */ +export interface UnzipFile { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The name of the file + */ + name: string; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA. If start() is called but there is no + * decompression stream available for this method, start() will throw. + */ + compression: number; + /** + * The compressed size of the file. Will not be present for archives created + * in a streaming fashion. + */ + size?: number; + /** + * The original size of the file. Will not be present for archives created + * in a streaming fashion. + */ + originalSize?: number; + /** + * Starts reading from the stream. Calling this function will always enable + * this stream, but ocassionally the stream will be enabled even without + * this being called. + */ + start(): void; + /** + * A method to terminate any internal workers used by the stream. ondata + * will not be called any further. + */ + terminate: AsyncTerminable; +} +/** + * Streaming pass-through decompression for ZIP archives + */ +export declare class UnzipPassThrough implements UnzipDecoder { + static compression: number; + ondata: AsyncFlateStreamHandler; + push(chunk: Uint8Array, final: boolean): void; +} +/** + * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for + * better performance. + */ +export declare class UnzipInflate implements UnzipDecoder { + static compression: number; + private i; + ondata: AsyncFlateStreamHandler; + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + constructor(); + push(chunk: Uint8Array, final: boolean): void; +} +/** + * Asynchronous streaming DEFLATE decompression for ZIP archives + */ +export declare class AsyncUnzipInflate implements UnzipDecoder { + static compression: number; + private i; + ondata: AsyncFlateStreamHandler; + terminate: AsyncTerminable; + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + constructor(_: string, sz?: number); + push(chunk: Uint8Array, final: boolean): void; +} +/** + * A ZIP archive decompression stream that emits files as they are discovered + */ +export declare class Unzip { + private d; + private c; + private p; + private k; + private o; + /** + * Creates a ZIP decompression stream + * @param cb The callback to call whenever a file in the ZIP archive is found + */ + constructor(cb?: UnzipFileHandler); + /** + * Pushes a chunk to be unzipped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Registers a decoder with the stream, allowing for files compressed with + * the compression type provided to be expanded correctly + * @param decoder The decoder constructor + */ + register(decoder: UnzipDecoderConstructor): void; + /** + * The handler to call whenever a file is discovered + */ + onfile: UnzipFileHandler; +} +/** + * Asynchronously decompresses a ZIP archive + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @param cb The callback to call with the decompressed files + * @returns A function that can be used to immediately terminate the unzipping + */ +export declare function unzip(data: Uint8Array, opts: AsyncUnzipOptions, cb: UnzipCallback): AsyncTerminable; +/** + * Asynchronously decompresses a ZIP archive + * @param data The raw compressed ZIP file + * @param cb The callback to call with the decompressed files + * @returns A function that can be used to immediately terminate the unzipping + */ +export declare function unzip(data: Uint8Array, cb: UnzipCallback): AsyncTerminable; +/** + * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better + * performance with more than one file. + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @returns The decompressed files + */ +export declare function unzipSync(data: Uint8Array, opts?: UnzipOptions): Unzipped; diff --git a/tools/ui/node_modules/fflate/esm/browser.js b/tools/ui/node_modules/fflate/esm/browser.js new file mode 100644 index 0000000000000000000000000000000000000000..82af0fdb655f00655d2da3354c4533744edcde6e --- /dev/null +++ b/tools/ui/node_modules/fflate/esm/browser.js @@ -0,0 +1,2692 @@ +// DEFLATE is a complex format; to read this code, you should probably check the RFC first: +// https://tools.ietf.org/html/rfc1951 +// You may also wish to take a look at the guide I made about this program: +// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad +// Some of the following code is similar to that of UZIP.js: +// https://github.com/photopea/UZIP.js +// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size. +// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint +// is better for memory in most engines (I *think*). +var ch2 = {}; +var wk = (function (c, id, msg, transfer, cb) { + var w = new Worker(ch2[id] || (ch2[id] = URL.createObjectURL(new Blob([ + c + ';addEventListener("error",function(e){e=e.error;postMessage({$e$:[e.message,e.code,e.stack]})})' + ], { type: 'text/javascript' })))); + w.onmessage = function (e) { + var d = e.data, ed = d.$e$; + if (ed) { + var err = new Error(ed[0]); + err['code'] = ed[1]; + err.stack = ed[2]; + cb(err, null); + } + else + cb(null, d); + }; + w.postMessage(msg, transfer); + return w; +}); + +// aliases for shorter compressed code (most minifers don't do this) +var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array; +// fixed length extra bits +var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]); +// fixed distance extra bits +var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]); +// code length index map +var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]); +// get base, reverse index map from extra bits +var freb = function (eb, start) { + var b = new u16(31); + for (var i = 0; i < 31; ++i) { + b[i] = start += 1 << eb[i - 1]; + } + // numbers here are at max 18 bits + var r = new i32(b[30]); + for (var i = 1; i < 30; ++i) { + for (var j = b[i]; j < b[i + 1]; ++j) { + r[j] = ((j - b[i]) << 5) | i; + } + } + return { b: b, r: r }; +}; +var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r; +// we can ignore the fact that the other numbers are wrong; they never happen anyway +fl[28] = 258, revfl[258] = 28; +var _b = freb(fdeb, 0), fd = _b.b, revfd = _b.r; +// map of value to reverse (assuming 16 bits) +var rev = new u16(32768); +for (var i = 0; i < 32768; ++i) { + // reverse table algorithm from SO + var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1); + x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2); + x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4); + rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1; +} +// create huffman tree from u8 "map": index -> code length for code index +// mb (max bits) must be at most 15 +// TODO: optimize/split up? +var hMap = (function (cd, mb, r) { + var s = cd.length; + // index + var i = 0; + // u16 "map": index -> # of codes with bit length = index + var l = new u16(mb); + // length of cd must be 288 (total # of codes) + for (; i < s; ++i) { + if (cd[i]) + ++l[cd[i] - 1]; + } + // u16 "map": index -> minimum code for bit length = index + var le = new u16(mb); + for (i = 1; i < mb; ++i) { + le[i] = (le[i - 1] + l[i - 1]) << 1; + } + var co; + if (r) { + // u16 "map": index -> number of actual bits, symbol for code + co = new u16(1 << mb); + // bits to remove for reverser + var rvb = 15 - mb; + for (i = 0; i < s; ++i) { + // ignore 0 lengths + if (cd[i]) { + // num encoding both symbol and bits read + var sv = (i << 4) | cd[i]; + // free bits + var r_1 = mb - cd[i]; + // start value + var v = le[cd[i] - 1]++ << r_1; + // m is end value + for (var m = v | ((1 << r_1) - 1); v <= m; ++v) { + // every 16 bit value starting with the code yields the same result + co[rev[v] >> rvb] = sv; + } + } + } + } + else { + co = new u16(s); + for (i = 0; i < s; ++i) { + if (cd[i]) { + co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]); + } + } + } + return co; +}); +// fixed length tree +var flt = new u8(288); +for (var i = 0; i < 144; ++i) + flt[i] = 8; +for (var i = 144; i < 256; ++i) + flt[i] = 9; +for (var i = 256; i < 280; ++i) + flt[i] = 7; +for (var i = 280; i < 288; ++i) + flt[i] = 8; +// fixed distance tree +var fdt = new u8(32); +for (var i = 0; i < 32; ++i) + fdt[i] = 5; +// fixed length map +var flm = /*#__PURE__*/ hMap(flt, 9, 0), flrm = /*#__PURE__*/ hMap(flt, 9, 1); +// fixed distance map +var fdm = /*#__PURE__*/ hMap(fdt, 5, 0), fdrm = /*#__PURE__*/ hMap(fdt, 5, 1); +// find max of array +var max = function (a) { + var m = a[0]; + for (var i = 1; i < a.length; ++i) { + if (a[i] > m) + m = a[i]; + } + return m; +}; +// read d, starting at bit p and mask with m +var bits = function (d, p, m) { + var o = (p / 8) | 0; + return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m; +}; +// read d, starting at bit p continuing for at least 16 bits +var bits16 = function (d, p) { + var o = (p / 8) | 0; + return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7)); +}; +// get end of byte +var shft = function (p) { return ((p + 7) / 8) | 0; }; +// typed array slice - allows garbage collector to free original reference, +// while being more compatible than .slice +var slc = function (v, s, e) { + if (s == null || s < 0) + s = 0; + if (e == null || e > v.length) + e = v.length; + // can't use .constructor in case user-supplied + return new u8(v.subarray(s, e)); +}; +/** + * Codes for errors generated within this library + */ +export var FlateErrorCode = { + UnexpectedEOF: 0, + InvalidBlockType: 1, + InvalidLengthLiteral: 2, + InvalidDistance: 3, + StreamFinished: 4, + NoStreamHandler: 5, + InvalidHeader: 6, + NoCallback: 7, + InvalidUTF8: 8, + ExtraFieldTooLong: 9, + InvalidDate: 10, + FilenameTooLong: 11, + StreamFinishing: 12, + InvalidZipData: 13, + UnknownCompressionMethod: 14 +}; +// error codes +var ec = [ + 'unexpected EOF', + 'invalid block type', + 'invalid length/literal', + 'invalid distance', + 'stream finished', + 'no stream handler', + , // determined by compression function + 'no callback', + 'invalid UTF-8 data', + 'extra field too long', + 'date not in range 1980-2099', + 'filename too long', + 'stream finishing', + 'invalid zip data' + // determined by unknown compression method +]; +; +var err = function (ind, msg, nt) { + var e = new Error(msg || ec[ind]); + e.code = ind; + if (Error.captureStackTrace) + Error.captureStackTrace(e, err); + if (!nt) + throw e; + return e; +}; +// expands raw DEFLATE data +var inflt = function (dat, st, buf, dict) { + // source length dict length + var sl = dat.length, dl = dict ? dict.length : 0; + if (!sl || st.f && !st.l) + return buf || new u8(0); + var noBuf = !buf; + // have to estimate size + var resize = noBuf || st.i != 2; + // no state + var noSt = st.i; + // Assumes roughly 33% compression ratio average + if (noBuf) + buf = new u8(sl * 3); + // ensure buffer can fit at least l elements + var cbuf = function (l) { + var bl = buf.length; + // need to increase size to fit + if (l > bl) { + // Double or set to necessary, whichever is greater + var nbuf = new u8(Math.max(bl * 2, l)); + nbuf.set(buf); + buf = nbuf; + } + }; + // last chunk bitpos bytes + var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n; + // total bits + var tbts = sl * 8; + do { + if (!lm) { + // BFINAL - this is only 1 when last chunk is next + final = bits(dat, pos, 1); + // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman + var type = bits(dat, pos + 1, 3); + pos += 3; + if (!type) { + // go to end of byte boundary + var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l; + if (t > sl) { + if (noSt) + err(0); + break; + } + // ensure size + if (resize) + cbuf(bt + l); + // Copy over uncompressed data + buf.set(dat.subarray(s, t), bt); + // Get new bitpos, update byte count + st.b = bt += l, st.p = pos = t * 8, st.f = final; + continue; + } + else if (type == 1) + lm = flrm, dm = fdrm, lbt = 9, dbt = 5; + else if (type == 2) { + // literal lengths + var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4; + var tl = hLit + bits(dat, pos + 5, 31) + 1; + pos += 14; + // length+distance tree + var ldt = new u8(tl); + // code length tree + var clt = new u8(19); + for (var i = 0; i < hcLen; ++i) { + // use index map to get real code + clt[clim[i]] = bits(dat, pos + i * 3, 7); + } + pos += hcLen * 3; + // code lengths bits + var clb = max(clt), clbmsk = (1 << clb) - 1; + // code lengths map + var clm = hMap(clt, clb, 1); + for (var i = 0; i < tl;) { + var r = clm[bits(dat, pos, clbmsk)]; + // bits read + pos += r & 15; + // symbol + var s = r >> 4; + // code length to copy + if (s < 16) { + ldt[i++] = s; + } + else { + // copy count + var c = 0, n = 0; + if (s == 16) + n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1]; + else if (s == 17) + n = 3 + bits(dat, pos, 7), pos += 3; + else if (s == 18) + n = 11 + bits(dat, pos, 127), pos += 7; + while (n--) + ldt[i++] = c; + } + } + // length tree distance tree + var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit); + // max length bits + lbt = max(lt); + // max dist bits + dbt = max(dt); + lm = hMap(lt, lbt, 1); + dm = hMap(dt, dbt, 1); + } + else + err(1); + if (pos > tbts) { + if (noSt) + err(0); + break; + } + } + // Make sure the buffer can hold this + the largest possible addition + // Maximum chunk size (practically, theoretically infinite) is 2^17 + if (resize) + cbuf(bt + 131072); + var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1; + var lpos = pos; + for (;; lpos = pos) { + // bits read, code + var c = lm[bits16(dat, pos) & lms], sym = c >> 4; + pos += c & 15; + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (!c) + err(2); + if (sym < 256) + buf[bt++] = sym; + else if (sym == 256) { + lpos = pos, lm = null; + break; + } + else { + var add = sym - 254; + // no extra bits needed if less + if (sym > 264) { + // index + var i = sym - 257, b = fleb[i]; + add = bits(dat, pos, (1 << b) - 1) + fl[i]; + pos += b; + } + // dist + var d = dm[bits16(dat, pos) & dms], dsym = d >> 4; + if (!d) + err(3); + pos += d & 15; + var dt = fd[dsym]; + if (dsym > 3) { + var b = fdeb[dsym]; + dt += bits16(dat, pos) & (1 << b) - 1, pos += b; + } + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (resize) + cbuf(bt + 131072); + var end = bt + add; + if (bt < dt) { + var shift = dl - dt, dend = Math.min(dt, end); + if (shift + bt < 0) + err(3); + for (; bt < dend; ++bt) + buf[bt] = dict[shift + bt]; + } + for (; bt < end; ++bt) + buf[bt] = buf[bt - dt]; + } + } + st.l = lm, st.p = lpos, st.b = bt, st.f = final; + if (lm) + final = 1, st.m = lbt, st.d = dm, st.n = dbt; + } while (!final); + // don't reallocate for streams or user buffers + return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt); +}; +// starting at p, write the minimum number of bits that can hold v to d +var wbits = function (d, p, v) { + v <<= p & 7; + var o = (p / 8) | 0; + d[o] |= v; + d[o + 1] |= v >> 8; +}; +// starting at p, write the minimum number of bits (>8) that can hold v to d +var wbits16 = function (d, p, v) { + v <<= p & 7; + var o = (p / 8) | 0; + d[o] |= v; + d[o + 1] |= v >> 8; + d[o + 2] |= v >> 16; +}; +// creates code lengths from a frequency table +var hTree = function (d, mb) { + // Need extra info to make a tree + var t = []; + for (var i = 0; i < d.length; ++i) { + if (d[i]) + t.push({ s: i, f: d[i] }); + } + var s = t.length; + var t2 = t.slice(); + if (!s) + return { t: et, l: 0 }; + if (s == 1) { + var v = new u8(t[0].s + 1); + v[t[0].s] = 1; + return { t: v, l: 1 }; + } + t.sort(function (a, b) { return a.f - b.f; }); + // after i2 reaches last ind, will be stopped + // freq must be greater than largest possible number of symbols + t.push({ s: -1, f: 25001 }); + var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2; + t[0] = { s: -1, f: l.f + r.f, l: l, r: r }; + // efficient algorithm from UZIP.js + // i0 is lookbehind, i2 is lookahead - after processing two low-freq + // symbols that combined have high freq, will start processing i2 (high-freq, + // non-composite) symbols instead + // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/ + while (i1 != s - 1) { + l = t[t[i0].f < t[i2].f ? i0++ : i2++]; + r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++]; + t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r }; + } + var maxSym = t2[0].s; + for (var i = 1; i < s; ++i) { + if (t2[i].s > maxSym) + maxSym = t2[i].s; + } + // code lengths + var tr = new u16(maxSym + 1); + // max bits in tree + var mbt = ln(t[i1 - 1], tr, 0); + if (mbt > mb) { + // more algorithms from UZIP.js + // TODO: find out how this code works (debt) + // ind debt + var i = 0, dt = 0; + // left cost + var lft = mbt - mb, cst = 1 << lft; + t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; }); + for (; i < s; ++i) { + var i2_1 = t2[i].s; + if (tr[i2_1] > mb) { + dt += cst - (1 << (mbt - tr[i2_1])); + tr[i2_1] = mb; + } + else + break; + } + dt >>= lft; + while (dt > 0) { + var i2_2 = t2[i].s; + if (tr[i2_2] < mb) + dt -= 1 << (mb - tr[i2_2]++ - 1); + else + ++i; + } + for (; i >= 0 && dt; --i) { + var i2_3 = t2[i].s; + if (tr[i2_3] == mb) { + --tr[i2_3]; + ++dt; + } + } + mbt = mb; + } + return { t: new u8(tr), l: mbt }; +}; +// get the max length and assign length codes +var ln = function (n, l, d) { + return n.s == -1 + ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) + : (l[n.s] = d); +}; +// length codes generation +var lc = function (c) { + var s = c.length; + // Note that the semicolon was intentional + while (s && !c[--s]) + ; + var cl = new u16(++s); + // ind num streak + var cli = 0, cln = c[0], cls = 1; + var w = function (v) { cl[cli++] = v; }; + for (var i = 1; i <= s; ++i) { + if (c[i] == cln && i != s) + ++cls; + else { + if (!cln && cls > 2) { + for (; cls > 138; cls -= 138) + w(32754); + if (cls > 2) { + w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305); + cls = 0; + } + } + else if (cls > 3) { + w(cln), --cls; + for (; cls > 6; cls -= 6) + w(8304); + if (cls > 2) + w(((cls - 3) << 5) | 8208), cls = 0; + } + while (cls--) + w(cln); + cls = 1; + cln = c[i]; + } + } + return { c: cl.subarray(0, cli), n: s }; +}; +// calculate the length of output from tree, code lengths +var clen = function (cf, cl) { + var l = 0; + for (var i = 0; i < cl.length; ++i) + l += cf[i] * cl[i]; + return l; +}; +// writes a fixed block +// returns the new bit pos +var wfblk = function (out, pos, dat) { + // no need to write 00 as type: TypedArray defaults to 0 + var s = dat.length; + var o = shft(pos + 2); + out[o] = s & 255; + out[o + 1] = s >> 8; + out[o + 2] = out[o] ^ 255; + out[o + 3] = out[o + 1] ^ 255; + for (var i = 0; i < s; ++i) + out[o + i + 4] = dat[i]; + return (o + 4 + s) * 8; +}; +// writes a block +var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) { + wbits(out, p++, final); + ++lf[256]; + var _a = hTree(lf, 15), dlt = _a.t, mlb = _a.l; + var _b = hTree(df, 15), ddt = _b.t, mdb = _b.l; + var _c = lc(dlt), lclt = _c.c, nlc = _c.n; + var _d = lc(ddt), lcdt = _d.c, ndc = _d.n; + var lcfreq = new u16(19); + for (var i = 0; i < lclt.length; ++i) + ++lcfreq[lclt[i] & 31]; + for (var i = 0; i < lcdt.length; ++i) + ++lcfreq[lcdt[i] & 31]; + var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l; + var nlcc = 19; + for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc) + ; + var flen = (bl + 5) << 3; + var ftlen = clen(lf, flt) + clen(df, fdt) + eb; + var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]; + if (bs >= 0 && flen <= ftlen && flen <= dtlen) + return wfblk(out, p, dat.subarray(bs, bs + bl)); + var lm, ll, dm, dl; + wbits(out, p, 1 + (dtlen < ftlen)), p += 2; + if (dtlen < ftlen) { + lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt; + var llm = hMap(lct, mlcb, 0); + wbits(out, p, nlc - 257); + wbits(out, p + 5, ndc - 1); + wbits(out, p + 10, nlcc - 4); + p += 14; + for (var i = 0; i < nlcc; ++i) + wbits(out, p + 3 * i, lct[clim[i]]); + p += 3 * nlcc; + var lcts = [lclt, lcdt]; + for (var it = 0; it < 2; ++it) { + var clct = lcts[it]; + for (var i = 0; i < clct.length; ++i) { + var len = clct[i] & 31; + wbits(out, p, llm[len]), p += lct[len]; + if (len > 15) + wbits(out, p, (clct[i] >> 5) & 127), p += clct[i] >> 12; + } + } + } + else { + lm = flm, ll = flt, dm = fdm, dl = fdt; + } + for (var i = 0; i < li; ++i) { + var sym = syms[i]; + if (sym > 255) { + var len = (sym >> 18) & 31; + wbits16(out, p, lm[len + 257]), p += ll[len + 257]; + if (len > 7) + wbits(out, p, (sym >> 23) & 31), p += fleb[len]; + var dst = sym & 31; + wbits16(out, p, dm[dst]), p += dl[dst]; + if (dst > 3) + wbits16(out, p, (sym >> 5) & 8191), p += fdeb[dst]; + } + else { + wbits16(out, p, lm[sym]), p += ll[sym]; + } + } + wbits16(out, p, lm[256]); + return p + ll[256]; +}; +// deflate options (nice << 13) | chain +var deo = /*#__PURE__*/ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]); +// empty +var et = /*#__PURE__*/ new u8(0); +// compresses data into a raw DEFLATE buffer +var dflt = function (dat, lvl, plvl, pre, post, st) { + var s = st.z || dat.length; + var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post); + // writing to this writes to the output buffer + var w = o.subarray(pre, o.length - post); + var lst = st.l; + var pos = (st.r || 0) & 7; + if (lvl) { + if (pos) + w[0] = st.r >> 3; + var opt = deo[lvl - 1]; + var n = opt >> 13, c = opt & 8191; + var msk_1 = (1 << plvl) - 1; + // prev 2-byte val map curr 2-byte val map + var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1); + var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1; + var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; }; + // 24576 is an arbitrary number of maximum symbols per block + // 424 buffer for last block + var syms = new i32(25000); + // length/literal freq distance freq + var lf = new u16(288), df = new u16(32); + // l/lcnt exbits index l/lind waitdx blkpos + var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0; + for (; i + 2 < s; ++i) { + // hash value + var hv = hsh(i); + // index mod 32768 previous index mod + var imod = i & 32767, pimod = head[hv]; + prev[imod] = pimod; + head[hv] = imod; + // We always should modify head and prev, but only add symbols if + // this data is not yet processed ("wait" for wait index) + if (wi <= i) { + // bytes remaining + var rem = s - i; + if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) { + pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos); + li = lc_1 = eb = 0, bs = i; + for (var j = 0; j < 286; ++j) + lf[j] = 0; + for (var j = 0; j < 30; ++j) + df[j] = 0; + } + // len dist chain + var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767; + if (rem > 2 && hv == hsh(i - dif)) { + var maxn = Math.min(n, rem) - 1; + var maxd = Math.min(32767, i); + // max possible length + // not capped at dif because decompressors implement "rolling" index population + var ml = Math.min(258, rem); + while (dif <= maxd && --ch_1 && imod != pimod) { + if (dat[i + l] == dat[i + l - dif]) { + var nl = 0; + for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl) + ; + if (nl > l) { + l = nl, d = dif; + // break out early when we reach "nice" (we are satisfied enough) + if (nl > maxn) + break; + // now, find the rarest 2-byte sequence within this + // length of literals and search for that instead. + // Much faster than just using the start + var mmd = Math.min(dif, nl - 2); + var md = 0; + for (var j = 0; j < mmd; ++j) { + var ti = i - dif + j & 32767; + var pti = prev[ti]; + var cd = ti - pti & 32767; + if (cd > md) + md = cd, pimod = ti; + } + } + } + // check the previous match + imod = pimod, pimod = prev[imod]; + dif += imod - pimod & 32767; + } + } + // d will be nonzero only when a match was found + if (d) { + // store both dist and len data in one int32 + // Make sure this is recognized as a len/dist with 28th bit (2^28) + syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d]; + var lin = revfl[l] & 31, din = revfd[d] & 31; + eb += fleb[lin] + fdeb[din]; + ++lf[257 + lin]; + ++df[din]; + wi = i + l; + ++lc_1; + } + else { + syms[li++] = dat[i]; + ++lf[dat[i]]; + } + } + } + for (i = Math.max(i, wi); i < s; ++i) { + syms[li++] = dat[i]; + ++lf[dat[i]]; + } + pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos); + if (!lst) { + st.r = (pos & 7) | w[(pos / 8) | 0] << 3; + // shft(pos) now 1 less if pos & 7 != 0 + pos -= 7; + st.h = head, st.p = prev, st.i = i, st.w = wi; + } + } + else { + for (var i = st.w || 0; i < s + lst; i += 65535) { + // end + var e = i + 65535; + if (e >= s) { + // write final block + w[(pos / 8) | 0] = lst; + e = s; + } + pos = wfblk(w, pos + 1, dat.subarray(i, e)); + } + st.i = s; + } + return slc(o, 0, pre + shft(pos) + post); +}; +// CRC32 table +var crct = /*#__PURE__*/ (function () { + var t = new Int32Array(256); + for (var i = 0; i < 256; ++i) { + var c = i, k = 9; + while (--k) + c = ((c & 1) && -306674912) ^ (c >>> 1); + t[i] = c; + } + return t; +})(); +// CRC32 +var crc = function () { + var c = -1; + return { + p: function (d) { + // closures have awful performance + var cr = c; + for (var i = 0; i < d.length; ++i) + cr = crct[(cr & 255) ^ d[i]] ^ (cr >>> 8); + c = cr; + }, + d: function () { return ~c; } + }; +}; +// Adler32 +var adler = function () { + var a = 1, b = 0; + return { + p: function (d) { + // closures have awful performance + var n = a, m = b; + var l = d.length | 0; + for (var i = 0; i != l;) { + var e = Math.min(i + 2655, l); + for (; i < e; ++i) + m += n += d[i]; + n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16); + } + a = n, b = m; + }, + d: function () { + a %= 65521, b %= 65521; + return (a & 255) << 24 | (a & 0xFF00) << 8 | (b & 255) << 8 | (b >> 8); + } + }; +}; +; +// deflate with opts +var dopt = function (dat, opt, pre, post, st) { + if (!st) { + st = { l: 1 }; + if (opt.dictionary) { + var dict = opt.dictionary.subarray(-32768); + var newDat = new u8(dict.length + dat.length); + newDat.set(dict); + newDat.set(dat, dict.length); + dat = newDat; + st.w = dict.length; + } + } + return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? (st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20) : (12 + opt.mem), pre, post, st); +}; +// Walmart object spread +var mrg = function (a, b) { + var o = {}; + for (var k in a) + o[k] = a[k]; + for (var k in b) + o[k] = b[k]; + return o; +}; +// worker clone +// This is possibly the craziest part of the entire codebase, despite how simple it may seem. +// The only parameter to this function is a closure that returns an array of variables outside of the function scope. +// We're going to try to figure out the variable names used in the closure as strings because that is crucial for workerization. +// We will return an object mapping of true variable name to value (basically, the current scope as a JS object). +// The reason we can't just use the original variable names is minifiers mangling the toplevel scope. +// This took me three weeks to figure out how to do. +var wcln = function (fn, fnStr, td) { + var dt = fn(); + var st = fn.toString(); + var ks = st.slice(st.indexOf('[') + 1, st.lastIndexOf(']')).replace(/\s+/g, '').split(','); + for (var i = 0; i < dt.length; ++i) { + var v = dt[i], k = ks[i]; + if (typeof v == 'function') { + fnStr += ';' + k + '='; + var st_1 = v.toString(); + if (v.prototype) { + // for global objects + if (st_1.indexOf('[native code]') != -1) { + var spInd = st_1.indexOf(' ', 8) + 1; + fnStr += st_1.slice(spInd, st_1.indexOf('(', spInd)); + } + else { + fnStr += st_1; + for (var t in v.prototype) + fnStr += ';' + k + '.prototype.' + t + '=' + v.prototype[t].toString(); + } + } + else + fnStr += st_1; + } + else + td[k] = v; + } + return fnStr; +}; +var ch = []; +// clone bufs +var cbfs = function (v) { + var tl = []; + for (var k in v) { + if (v[k].buffer) { + tl.push((v[k] = new v[k].constructor(v[k])).buffer); + } + } + return tl; +}; +// use a worker to execute code +var wrkr = function (fns, init, id, cb) { + if (!ch[id]) { + var fnStr = '', td_1 = {}, m = fns.length - 1; + for (var i = 0; i < m; ++i) + fnStr = wcln(fns[i], fnStr, td_1); + ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 }; + } + var td = mrg({}, ch[id].e); + return wk(ch[id].c + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb); +}; +// base async inflate fn +var bInflt = function () { return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt]; }; +var bDflt = function () { return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; }; +// gzip extra +var gze = function () { return [gzh, gzhl, wbytes, crc, crct]; }; +// gunzip extra +var guze = function () { return [gzs, gzl]; }; +// zlib extra +var zle = function () { return [zlh, wbytes, adler]; }; +// unzlib extra +var zule = function () { return [zls]; }; +// post buf +var pbf = function (msg) { return postMessage(msg, [msg.buffer]); }; +// get opts +var gopt = function (o) { return o && { + out: o.size && new u8(o.size), + dictionary: o.dictionary +}; }; +// async helper +var cbify = function (dat, opts, fns, init, id, cb) { + var w = wrkr(fns, init, id, function (err, dat) { + w.terminate(); + cb(err, dat); + }); + w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []); + return function () { w.terminate(); }; +}; +// auto stream +var astrm = function (strm) { + strm.ondata = function (dat, final) { return postMessage([dat, final], [dat.buffer]); }; + return function (ev) { + if (ev.data[0]) { + strm.push(ev.data[0], ev.data[1]); + postMessage([ev.data[0].length]); + } + else + strm.flush(ev.data[1]); + }; +}; +// async stream attach +var astrmify = function (fns, strm, opts, init, id, flush, ext) { + var t; + var w = wrkr(fns, init, id, function (err, dat) { + if (err) + w.terminate(), strm.ondata.call(strm, err); + else if (!Array.isArray(dat)) + ext(dat); + else if (dat.length == 1) { + strm.queuedSize -= dat[0]; + if (strm.ondrain) + strm.ondrain(dat[0]); + } + else { + if (dat[1]) + w.terminate(); + strm.ondata.call(strm, err, dat[0], dat[1]); + } + }); + w.postMessage(opts); + strm.queuedSize = 0; + strm.push = function (d, f) { + if (!strm.ondata) + err(5); + if (t) + strm.ondata(err(4, 0, 1), null, !!f); + strm.queuedSize += d.length; + // can fail for cross-realm Uint8Array, but ok - only a small performance penalty + w.postMessage([d, t = f], d.buffer instanceof ArrayBuffer ? [d.buffer] : []); + }; + strm.terminate = function () { w.terminate(); }; + if (flush) { + strm.flush = function (sync) { w.postMessage([0, sync]); }; + } +}; +// read 2 bytes +var b2 = function (d, b) { return d[b] | (d[b + 1] << 8); }; +// read 4 bytes +var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; }; +// read 8 bytes +var b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); }; +// write bytes +var wbytes = function (d, b, v) { + for (; v; ++b) + d[b] = v, v >>>= 8; +}; +// gzip header +var gzh = function (c, o) { + var fn = o.filename; + c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3; // assume Unix + if (o.mtime != 0) + wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1000)); + if (fn) { + c[3] = 8; + for (var i = 0; i <= fn.length; ++i) + c[i + 10] = fn.charCodeAt(i); + } +}; +// gzip footer: -8 to -4 = CRC, -4 to -0 is length +// gzip start +var gzs = function (d) { + if (d[0] != 31 || d[1] != 139 || d[2] != 8) + err(6, 'invalid gzip data'); + var flg = d[3]; + var st = 10; + if (flg & 4) + st += (d[10] | d[11] << 8) + 2; + for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) + ; + return st + (flg & 2); +}; +// gzip length +var gzl = function (d) { + var l = d.length; + return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0; +}; +// gzip header length +var gzhl = function (o) { return 10 + (o.filename ? o.filename.length + 1 : 0); }; +// zlib header +var zlh = function (c, o) { + var lv = o.level, fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2; + c[0] = 120, c[1] = (fl << 6) | (o.dictionary && 32); + c[1] |= 31 - ((c[0] << 8) | c[1]) % 31; + if (o.dictionary) { + var h = adler(); + h.p(o.dictionary); + wbytes(c, 2, h.d()); + } +}; +// zlib start +var zls = function (d, dict) { + if ((d[0] & 15) != 8 || (d[0] >> 4) > 7 || ((d[0] << 8 | d[1]) % 31)) + err(6, 'invalid zlib data'); + if ((d[1] >> 5 & 1) == +!dict) + err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary'); + return (d[1] >> 3 & 4) + 2; +}; +function StrmOpt(opts, cb) { + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + return opts; +} +/** + * Streaming DEFLATE compression + */ +var Deflate = /*#__PURE__*/ (function () { + function Deflate(opts, cb) { + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + this.o = opts || {}; + this.s = { l: 0, i: 32768, w: 32768, z: 32768 }; + // Buffer length must always be 0 mod 32768 for index calculations to be correct when modifying head and prev + // 98304 = 32768 (lookback) + 65536 (common chunk size) + this.b = new u8(98304); + if (this.o.dictionary) { + var dict = this.o.dictionary.subarray(-32768); + this.b.set(dict, 32768 - dict.length); + this.s.i = 32768 - dict.length; + } + } + Deflate.prototype.p = function (c, f) { + this.ondata(dopt(c, this.o, 0, 0, this.s), f); + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Deflate.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (this.s.l) + err(4); + var endLen = chunk.length + this.s.z; + if (endLen > this.b.length) { + if (endLen > 2 * this.b.length - 32768) { + var newBuf = new u8(endLen & -32768); + newBuf.set(this.b.subarray(0, this.s.z)); + this.b = newBuf; + } + var split = this.b.length - this.s.z; + this.b.set(chunk.subarray(0, split), this.s.z); + this.s.z = this.b.length; + this.p(this.b, false); + this.b.set(this.b.subarray(-32768)); + this.b.set(chunk.subarray(split), 32768); + this.s.z = chunk.length - split + 32768; + this.s.i = 32766, this.s.w = 32768; + } + else { + this.b.set(chunk, this.s.z); + this.s.z += chunk.length; + } + this.s.l = final & 1; + if (this.s.z > this.s.w + 8191 || final) { + this.p(this.b, final || false); + this.s.w = this.s.i, this.s.i -= 2; + } + if (final) { + // cleanup unneeded buffers/state to reduce memory usage + this.s = this.o = {}; + this.b = et; + } + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + Deflate.prototype.flush = function (sync) { + if (!this.ondata) + err(5); + if (this.s.l) + err(4); + this.p(this.b, false); + this.s.w = this.s.i, this.s.i -= 2; + // could technically skip writing the type-0 block for (this.s.r & 7) == 0, + // but the deterministic trailer (00 00 FF FF) is useful in some situations + if (sync) { + var c = new u8(6); + c[0] = this.s.r >> 3; + // write empty, non-final type-0 block + var ep = wfblk(c, this.s.r, et); + this.s.r = 0; + this.ondata(c.subarray(0, ep >> 3), false); + } + }; + return Deflate; +}()); +export { Deflate }; +/** + * Asynchronous streaming DEFLATE compression + */ +var AsyncDeflate = /*#__PURE__*/ (function () { + function AsyncDeflate(opts, cb) { + astrmify([ + bDflt, + function () { return [astrm, Deflate]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Deflate(ev.data); + onmessage = astrm(strm); + }, 6, 1); + } + return AsyncDeflate; +}()); +export { AsyncDeflate }; +export function deflate(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + ], function (ev) { return pbf(deflateSync(ev.data[0], ev.data[1])); }, 0, cb); +} +/** + * Compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @returns The deflated version of the data + */ +export function deflateSync(data, opts) { + return dopt(data, opts || {}, 0, 0); +} +/** + * Streaming DEFLATE decompression + */ +var Inflate = /*#__PURE__*/ (function () { + function Inflate(opts, cb) { + // no StrmOpt here to avoid adding to workerizer + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768); + this.s = { i: 0, b: dict ? dict.length : 0 }; + this.o = new u8(32768); + this.p = new u8(0); + if (dict) + this.o.set(dict); + } + Inflate.prototype.e = function (c) { + if (!this.ondata) + err(5); + if (this.d) + err(4); + if (!this.p.length) + this.p = c; + else if (c.length) { + var n = new u8(this.p.length + c.length); + n.set(this.p), n.set(c, this.p.length), this.p = n; + } + }; + Inflate.prototype.c = function (final) { + this.s.i = +(this.d = final || false); + var bts = this.s.b; + var dt = inflt(this.p, this.s, this.o); + this.ondata(slc(dt, bts, this.s.b), this.d); + this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length; + this.p = slc(this.p, (this.s.p / 8) | 0), this.s.p &= 7; + }; + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the final chunk + */ + Inflate.prototype.push = function (chunk, final) { + this.e(chunk), this.c(final); + }; + return Inflate; +}()); +export { Inflate }; +/** + * Asynchronous streaming DEFLATE decompression + */ +var AsyncInflate = /*#__PURE__*/ (function () { + function AsyncInflate(opts, cb) { + astrmify([ + bInflt, + function () { return [astrm, Inflate]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Inflate(ev.data); + onmessage = astrm(strm); + }, 7, 0); + } + return AsyncInflate; +}()); +export { AsyncInflate }; +export function inflate(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt + ], function (ev) { return pbf(inflateSync(ev.data[0], gopt(ev.data[1]))); }, 1, cb); +} +export function inflateSync(data, opts) { + return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary); +} +// before you yell at me for not just using extends, my reason is that TS inheritance is hard to workerize. +/** + * Streaming GZIP compression + */ +var Gzip = /*#__PURE__*/ (function () { + function Gzip(opts, cb) { + this.c = crc(); + this.l = 0; + this.v = 1; + Deflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Gzip.prototype.push = function (chunk, final) { + this.c.p(chunk); + this.l += chunk.length; + Deflate.prototype.push.call(this, chunk, final); + }; + Gzip.prototype.p = function (c, f) { + var raw = dopt(c, this.o, this.v && gzhl(this.o), f && 8, this.s); + if (this.v) + gzh(raw, this.o), this.v = 0; + if (f) + wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l); + this.ondata(raw, f); + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + Gzip.prototype.flush = function (sync) { + Deflate.prototype.flush.call(this, sync); + }; + return Gzip; +}()); +export { Gzip }; +/** + * Asynchronous streaming GZIP compression + */ +var AsyncGzip = /*#__PURE__*/ (function () { + function AsyncGzip(opts, cb) { + astrmify([ + bDflt, + gze, + function () { return [astrm, Deflate, Gzip]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Gzip(ev.data); + onmessage = astrm(strm); + }, 8, 1); + } + return AsyncGzip; +}()); +export { AsyncGzip }; +export function gzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + gze, + function () { return [gzipSync]; } + ], function (ev) { return pbf(gzipSync(ev.data[0], ev.data[1])); }, 2, cb); +} +/** + * Compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @returns The gzipped version of the data + */ +export function gzipSync(data, opts) { + if (!opts) + opts = {}; + var c = crc(), l = data.length; + c.p(data); + var d = dopt(data, opts, gzhl(opts), 8), s = d.length; + return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d; +} +/** + * Streaming single or multi-member GZIP decompression + */ +var Gunzip = /*#__PURE__*/ (function () { + function Gunzip(opts, cb) { + this.v = 1; + this.r = 0; + Inflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Gunzip.prototype.push = function (chunk, final) { + Inflate.prototype.e.call(this, chunk); + this.r += chunk.length; + if (this.v) { + var p = this.p.subarray(this.v - 1); + var s = p.length > 3 ? gzs(p) : 4; + if (s > p.length) { + if (!final) + return; + } + else if (this.v > 1 && this.onmember) { + this.onmember(this.r - p.length); + } + this.p = p.subarray(s), this.v = 0; + } + // necessary to prevent TS from using the closure value + // This allows for workerization to function correctly + Inflate.prototype.c.call(this, 0); + // process concatenated GZIP + if (this.s.f && !this.s.l) { + this.v = shft(this.s.p) + 9; + this.s = { i: 0 }; + this.o = new u8(0); + this.push(new u8(0), final); + } + else if (final) { + Inflate.prototype.c.call(this, final); + } + }; + return Gunzip; +}()); +export { Gunzip }; +/** + * Asynchronous streaming single or multi-member GZIP decompression + */ +var AsyncGunzip = /*#__PURE__*/ (function () { + function AsyncGunzip(opts, cb) { + var _this = this; + astrmify([ + bInflt, + guze, + function () { return [astrm, Inflate, Gunzip]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Gunzip(ev.data); + strm.onmember = function (offset) { return postMessage(offset); }; + onmessage = astrm(strm); + }, 9, 0, function (offset) { return _this.onmember && _this.onmember(offset); }); + } + return AsyncGunzip; +}()); +export { AsyncGunzip }; +export function gunzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt, + guze, + function () { return [gunzipSync]; } + ], function (ev) { return pbf(gunzipSync(ev.data[0], ev.data[1])); }, 3, cb); +} +export function gunzipSync(data, opts) { + var st = gzs(data); + if (st + 8 > data.length) + err(6, 'invalid gzip data'); + return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary); +} +/** + * Streaming Zlib compression + */ +var Zlib = /*#__PURE__*/ (function () { + function Zlib(opts, cb) { + this.c = adler(); + this.v = 1; + Deflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be zlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Zlib.prototype.push = function (chunk, final) { + this.c.p(chunk); + Deflate.prototype.push.call(this, chunk, final); + }; + Zlib.prototype.p = function (c, f) { + var raw = dopt(c, this.o, this.v && (this.o.dictionary ? 6 : 2), f && 4, this.s); + if (this.v) + zlh(raw, this.o), this.v = 0; + if (f) + wbytes(raw, raw.length - 4, this.c.d()); + this.ondata(raw, f); + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + Zlib.prototype.flush = function (sync) { + Deflate.prototype.flush.call(this, sync); + }; + return Zlib; +}()); +export { Zlib }; +/** + * Asynchronous streaming Zlib compression + */ +var AsyncZlib = /*#__PURE__*/ (function () { + function AsyncZlib(opts, cb) { + astrmify([ + bDflt, + zle, + function () { return [astrm, Deflate, Zlib]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Zlib(ev.data); + onmessage = astrm(strm); + }, 10, 1); + } + return AsyncZlib; +}()); +export { AsyncZlib }; +export function zlib(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + zle, + function () { return [zlibSync]; } + ], function (ev) { return pbf(zlibSync(ev.data[0], ev.data[1])); }, 4, cb); +} +/** + * Compress data with Zlib + * @param data The data to compress + * @param opts The compression options + * @returns The zlib-compressed version of the data + */ +export function zlibSync(data, opts) { + if (!opts) + opts = {}; + var a = adler(); + a.p(data); + var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4); + return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d; +} +/** + * Streaming Zlib decompression + */ +var Unzlib = /*#__PURE__*/ (function () { + function Unzlib(opts, cb) { + Inflate.call(this, opts, cb); + this.v = opts && opts.dictionary ? 2 : 1; + } + /** + * Pushes a chunk to be unzlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Unzlib.prototype.push = function (chunk, final) { + Inflate.prototype.e.call(this, chunk); + if (this.v) { + if (this.p.length < 6 && !final) + return; + this.p = this.p.subarray(zls(this.p, this.v - 1)), this.v = 0; + } + if (final) { + if (this.p.length < 4) + err(6, 'invalid zlib data'); + this.p = this.p.subarray(0, -4); + } + // necessary to prevent TS from using the closure value + // This allows for workerization to function correctly + Inflate.prototype.c.call(this, final); + }; + return Unzlib; +}()); +export { Unzlib }; +/** + * Asynchronous streaming Zlib decompression + */ +var AsyncUnzlib = /*#__PURE__*/ (function () { + function AsyncUnzlib(opts, cb) { + astrmify([ + bInflt, + zule, + function () { return [astrm, Inflate, Unzlib]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Unzlib(ev.data); + onmessage = astrm(strm); + }, 11, 0); + } + return AsyncUnzlib; +}()); +export { AsyncUnzlib }; +export function unzlib(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt, + zule, + function () { return [unzlibSync]; } + ], function (ev) { return pbf(unzlibSync(ev.data[0], gopt(ev.data[1]))); }, 5, cb); +} +export function unzlibSync(data, opts) { + return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary); +} +// Default algorithm for compression (used because having a known output size allows faster decompression) +export { gzip as compress, AsyncGzip as AsyncCompress }; +export { gzipSync as compressSync, Gzip as Compress }; +/** + * Streaming GZIP, Zlib, or raw DEFLATE decompression + */ +var Decompress = /*#__PURE__*/ (function () { + function Decompress(opts, cb) { + this.o = StrmOpt.call(this, opts, cb) || {}; + this.G = Gunzip; + this.I = Inflate; + this.Z = Unzlib; + } + // init substream + // overriden by AsyncDecompress + Decompress.prototype.i = function () { + var _this = this; + this.s.ondata = function (dat, final) { + _this.ondata(dat, final); + }; + }; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Decompress.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (!this.s) { + if (this.p && this.p.length) { + var n = new u8(this.p.length + chunk.length); + n.set(this.p), n.set(chunk, this.p.length); + } + else + this.p = chunk; + if (this.p.length > 2) { + this.s = (this.p[0] == 31 && this.p[1] == 139 && this.p[2] == 8) + ? new this.G(this.o) + : ((this.p[0] & 15) != 8 || (this.p[0] >> 4) > 7 || ((this.p[0] << 8 | this.p[1]) % 31)) + ? new this.I(this.o) + : new this.Z(this.o); + this.i(); + this.s.push(this.p, final); + this.p = null; + } + } + else + this.s.push(chunk, final); + }; + return Decompress; +}()); +export { Decompress }; +/** + * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression + */ +var AsyncDecompress = /*#__PURE__*/ (function () { + function AsyncDecompress(opts, cb) { + Decompress.call(this, opts, cb); + this.queuedSize = 0; + this.G = AsyncGunzip; + this.I = AsyncInflate; + this.Z = AsyncUnzlib; + } + AsyncDecompress.prototype.i = function () { + var _this = this; + this.s.ondata = function (err, dat, final) { + _this.ondata(err, dat, final); + }; + this.s.ondrain = function (size) { + _this.queuedSize -= size; + if (_this.ondrain) + _this.ondrain(size); + }; + }; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + AsyncDecompress.prototype.push = function (chunk, final) { + this.queuedSize += chunk.length; + Decompress.prototype.push.call(this, chunk, final); + }; + return AsyncDecompress; +}()); +export { AsyncDecompress }; +export function decompress(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return (data[0] == 31 && data[1] == 139 && data[2] == 8) + ? gunzip(data, opts, cb) + : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31)) + ? inflate(data, opts, cb) + : unzlib(data, opts, cb); +} +/** + * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export function decompressSync(data, opts) { + return (data[0] == 31 && data[1] == 139 && data[2] == 8) + ? gunzipSync(data, opts) + : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31)) + ? inflateSync(data, opts) + : unzlibSync(data, opts); +} +// flatten a directory structure +var fltn = function (d, p, t, o) { + for (var k in d) { + var val = d[k], n = p + k, op = o; + if (Array.isArray(val)) + op = mrg(o, val[1]), val = val[0]; + if (ArrayBuffer.isView(val)) + t[n] = [val, op]; + else { + t[n += '/'] = [new u8(0), op]; + fltn(val, n, t, o); + } + } +}; +// text encoder +var te = typeof TextEncoder != 'undefined' && /*#__PURE__*/ new TextEncoder(); +// text decoder +var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder(); +// text decoder stream +var tds = 0; +try { + td.decode(et, { stream: true }); + tds = 1; +} +catch (e) { } +// decode UTF8 +var dutf8 = function (d) { + for (var r = '', i = 0;;) { + var c = d[i++]; + var eb = (c > 127) + (c > 223) + (c > 239); + if (i + eb > d.length) + return { s: r, r: slc(d, i - 1) }; + if (!eb) + r += String.fromCharCode(c); + else if (eb == 3) { + c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536, + r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023)); + } + else if (eb & 1) + r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63)); + else + r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)); + } +}; +/** + * Streaming UTF-8 decoding + */ +var DecodeUTF8 = /*#__PURE__*/ (function () { + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is decoded + */ + function DecodeUTF8(cb) { + this.ondata = cb; + if (tds) + this.t = new TextDecoder(); + else + this.p = et; + } + /** + * Pushes a chunk to be decoded from UTF-8 binary + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + DecodeUTF8.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + final = !!final; + if (this.t) { + this.ondata(this.t.decode(chunk, { stream: true }), final); + if (final) { + if (this.t.decode().length) + err(8); + this.t = null; + } + return; + } + if (!this.p) + err(4); + var dat = new u8(this.p.length + chunk.length); + dat.set(this.p); + dat.set(chunk, this.p.length); + var _a = dutf8(dat), s = _a.s, r = _a.r; + if (final) { + if (r.length) + err(8); + this.p = null; + } + else + this.p = r; + this.ondata(s, final); + }; + return DecodeUTF8; +}()); +export { DecodeUTF8 }; +/** + * Streaming UTF-8 encoding + */ +var EncodeUTF8 = /*#__PURE__*/ (function () { + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is encoded + */ + function EncodeUTF8(cb) { + this.ondata = cb; + } + /** + * Pushes a chunk to be encoded to UTF-8 + * @param chunk The string data to push + * @param final Whether this is the last chunk + */ + EncodeUTF8.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (this.d) + err(4); + this.ondata(strToU8(chunk), this.d = final || false); + }; + return EncodeUTF8; +}()); +export { EncodeUTF8 }; +/** + * Converts a string into a Uint8Array for use with compression/decompression methods + * @param str The string to encode + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless decoding a binary string. + * @returns The string encoded in UTF-8/Latin-1 binary + */ +export function strToU8(str, latin1) { + if (latin1) { + var ar_1 = new u8(str.length); + for (var i = 0; i < str.length; ++i) + ar_1[i] = str.charCodeAt(i); + return ar_1; + } + if (te) + return te.encode(str); + var l = str.length; + var ar = new u8(str.length + (str.length >> 1)); + var ai = 0; + var w = function (v) { ar[ai++] = v; }; + for (var i = 0; i < l; ++i) { + if (ai + 5 > ar.length) { + var n = new u8(ai + 8 + ((l - i) << 1)); + n.set(ar); + ar = n; + } + var c = str.charCodeAt(i); + if (c < 128 || latin1) + w(c); + else if (c < 2048) + w(192 | (c >> 6)), w(128 | (c & 63)); + else if (c > 55295 && c < 57344) + c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023), + w(240 | (c >> 18)), w(128 | ((c >> 12) & 63)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63)); + else + w(224 | (c >> 12)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63)); + } + return slc(ar, 0, ai); +} +/** + * Converts a Uint8Array to a string + * @param dat The data to decode to string + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless encoding to binary string. + * @returns The original UTF-8/Latin-1 string + */ +export function strFromU8(dat, latin1) { + if (latin1) { + var r = ''; + for (var i = 0; i < dat.length; i += 16384) + r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384)); + return r; + } + else if (td) { + return td.decode(dat); + } + else { + var _a = dutf8(dat), s = _a.s, r = _a.r; + if (r.length) + err(8); + return s; + } +} +; +// deflate bit flag +var dbf = function (l) { return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0; }; +// skip local zip header +var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); }; +// read zip header +var zh = function (d, b, z) { + var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl; + var _a = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a[0], su = _a[1], off = _a[2]; + return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off]; +}; +// read zip64 header sizes +var z64hs = function (d, b, l, z, sc, su, off) { + var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l; + var nf = nsc + nsu + noff; + if (z && nf) { + for (; b + 4 < e; b += 4 + b2(d, b + 2)) { + if (b2(d, b) == 1) { + return [ + nsc ? b8(d, b + 4 + 8 * nsu) : sc, + nsu ? b8(d, b + 4) : su, + noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off, + 1 + ]; + } + } + // z == 2 for unknown whether or not zip64 + if (z < 2) + err(13); + } + return [sc, su, off, 0]; +}; +// extra field length +var exfl = function (ex) { + var le = 0; + if (ex) { + for (var k in ex) { + var l = ex[k].length; + if (l > 65535) + err(9); + le += l + 4; + } + } + return le; +}; +// write zip header +var wzh = function (d, b, f, fn, u, c, ce, co) { + var fl = fn.length, ex = f.extra, col = co && co.length; + var exl = exfl(ex); + wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4; + if (ce != null) + d[b++] = 20, d[b++] = f.os; + d[b] = 20, b += 2; // spec compliance? what's that? + d[b++] = (f.flag << 1) | (c < 0 && 8), d[b++] = u && 8; + d[b++] = f.compression & 255, d[b++] = f.compression >> 8; + var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980; + if (y < 0 || y > 119) + err(10); + wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >> 1)), b += 4; + if (c != -1) { + wbytes(d, b, f.crc); + wbytes(d, b + 4, c < 0 ? -c - 2 : c); + wbytes(d, b + 8, f.size); + } + wbytes(d, b + 12, fl); + wbytes(d, b + 14, exl), b += 16; + if (ce != null) { + wbytes(d, b, col); + wbytes(d, b + 6, f.attrs); + wbytes(d, b + 10, ce), b += 14; + } + d.set(fn, b); + b += fl; + if (exl) { + for (var k in ex) { + var exf = ex[k], l = exf.length; + wbytes(d, b, +k); + wbytes(d, b + 2, l); + d.set(exf, b + 4), b += 4 + l; + } + } + if (col) + d.set(co, b), b += col; + return b; +}; +// write zip footer (end of central directory) +var wzf = function (o, b, c, d, e) { + wbytes(o, b, 0x6054B50); // skip disk + wbytes(o, b + 8, c); + wbytes(o, b + 10, c); + wbytes(o, b + 12, d); + wbytes(o, b + 16, e); +}; +/** + * A pass-through stream to keep data uncompressed in a ZIP archive. + */ +var ZipPassThrough = /*#__PURE__*/ (function () { + /** + * Creates a pass-through stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + */ + function ZipPassThrough(filename) { + this.filename = filename; + this.c = crc(); + this.size = 0; + this.compression = 0; + } + /** + * Processes a chunk and pushes to the output stream. You can override this + * method in a subclass for custom behavior, but by default this passes + * the data through. You must call this.ondata(err, chunk, final) at some + * point in this method. + * @param chunk The chunk to process + * @param final Whether this is the last chunk + */ + ZipPassThrough.prototype.process = function (chunk, final) { + this.ondata(null, chunk, final); + }; + /** + * Pushes a chunk to be added. If you are subclassing this with a custom + * compression algorithm, note that you must push data from the source + * file only, pre-compression. + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + ZipPassThrough.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + this.c.p(chunk); + this.size += chunk.length; + if (final) + this.crc = this.c.d(); + // we shouldn't really do this cast, but properly handling ArrayBufferLike + // makes the API unergonomic with Buffer + this.process(chunk, final || false); + }; + return ZipPassThrough; +}()); +export { ZipPassThrough }; +// I don't extend because TypeScript extension adds 1kB of runtime bloat +/** + * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate + * for better performance + */ +var ZipDeflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + function ZipDeflate(filename, opts) { + var _this = this; + if (!opts) + opts = {}; + ZipPassThrough.call(this, filename); + this.d = new Deflate(opts, function (dat, final) { + _this.ondata(null, dat, final); + }); + this.compression = 8; + this.flag = dbf(opts.level); + } + ZipDeflate.prototype.process = function (chunk, final) { + try { + this.d.push(chunk, final); + } + catch (e) { + this.ondata(e, null, final); + } + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + ZipDeflate.prototype.push = function (chunk, final) { + ZipPassThrough.prototype.push.call(this, chunk, final); + }; + return ZipDeflate; +}()); +export { ZipDeflate }; +/** + * Asynchronous streaming DEFLATE compression for ZIP archives + */ +var AsyncZipDeflate = /*#__PURE__*/ (function () { + /** + * Creates an asynchronous DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + function AsyncZipDeflate(filename, opts) { + var _this = this; + if (!opts) + opts = {}; + ZipPassThrough.call(this, filename); + this.d = new AsyncDeflate(opts, function (err, dat, final) { + _this.ondata(err, dat, final); + }); + this.compression = 8; + this.flag = dbf(opts.level); + this.terminate = this.d.terminate; + } + AsyncZipDeflate.prototype.process = function (chunk, final) { + this.d.push(chunk, final); + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + AsyncZipDeflate.prototype.push = function (chunk, final) { + ZipPassThrough.prototype.push.call(this, chunk, final); + }; + return AsyncZipDeflate; +}()); +export { AsyncZipDeflate }; +// TODO: Better tree shaking +/** + * A zippable archive to which files can incrementally be added + */ +var Zip = /*#__PURE__*/ (function () { + /** + * Creates an empty ZIP archive to which files can be added + * @param cb The callback to call whenever data for the generated ZIP archive + * is available + */ + function Zip(cb) { + this.ondata = cb; + this.u = []; + this.d = 1; + } + /** + * Adds a file to the ZIP archive + * @param file The file stream to add + */ + Zip.prototype.add = function (file) { + var _this = this; + if (!this.ondata) + err(5); + // finishing or finished + if (this.d & 2) + this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, false); + else { + var f = strToU8(file.filename), fl_1 = f.length; + var com = file.comment, o = com && strToU8(com); + var u = fl_1 != file.filename.length || (o && (com.length != o.length)); + var hl_1 = fl_1 + exfl(file.extra) + 30; + if (fl_1 > 65535) + this.ondata(err(11, 0, 1), null, false); + var header = new u8(hl_1); + wzh(header, 0, file, f, u, -1); + var chks_1 = [header]; + var pAll_1 = function () { + for (var _i = 0, chks_2 = chks_1; _i < chks_2.length; _i++) { + var chk = chks_2[_i]; + _this.ondata(null, chk, false); + } + chks_1 = []; + }; + var tr_1 = this.d; + this.d = 0; + var ind_1 = this.u.length; + var uf_1 = mrg(file, { + f: f, + u: u, + o: o, + t: function () { + if (file.terminate) + file.terminate(); + }, + r: function () { + pAll_1(); + if (tr_1) { + var nxt = _this.u[ind_1 + 1]; + if (nxt) + nxt.r(); + else + _this.d = 1; + } + tr_1 = 1; + } + }); + var cl_1 = 0; + file.ondata = function (err, dat, final) { + if (err) { + _this.ondata(err, dat, final); + _this.terminate(); + } + else { + cl_1 += dat.length; + chks_1.push(dat); + if (final) { + var dd = new u8(16); + wbytes(dd, 0, 0x8074B50); + wbytes(dd, 4, file.crc); + wbytes(dd, 8, cl_1); + wbytes(dd, 12, file.size); + chks_1.push(dd); + uf_1.c = cl_1, uf_1.b = hl_1 + cl_1 + 16, uf_1.crc = file.crc, uf_1.size = file.size; + if (tr_1) + uf_1.r(); + tr_1 = 1; + } + else if (tr_1) + pAll_1(); + } + }; + this.u.push(uf_1); + } + }; + /** + * Ends the process of adding files and prepares to emit the final chunks. + * This *must* be called after adding all desired files for the resulting + * ZIP file to work properly. + */ + Zip.prototype.end = function () { + var _this = this; + if (this.d & 2) { + this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, true); + return; + } + if (this.d) + this.e(); + else + this.u.push({ + r: function () { + if (!(_this.d & 1)) + return; + _this.u.splice(-1, 1); + _this.e(); + }, + t: function () { } + }); + this.d = 3; + }; + Zip.prototype.e = function () { + var bt = 0, l = 0, tl = 0; + for (var _i = 0, _a = this.u; _i < _a.length; _i++) { + var f = _a[_i]; + tl += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0); + } + var out = new u8(tl + 22); + for (var _b = 0, _c = this.u; _b < _c.length; _b++) { + var f = _c[_b]; + wzh(out, bt, f, f.f, f.u, -f.c - 2, l, f.o); + bt += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0), l += f.b; + } + wzf(out, bt, this.u.length, tl, l); + this.ondata(null, out, true); + this.d = 2; + }; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to add() will fail. + */ + Zip.prototype.terminate = function () { + for (var _i = 0, _a = this.u; _i < _a.length; _i++) { + var f = _a[_i]; + f.t(); + } + this.d = 2; + }; + return Zip; +}()); +export { Zip }; +export function zip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + var r = {}; + fltn(data, '', r, opts); + var k = Object.keys(r); + var lft = k.length, o = 0, tot = 0; + var slft = lft, files = new Array(lft); + var term = []; + var tAll = function () { + for (var i = 0; i < term.length; ++i) + term[i](); + }; + var cbd = function (a, b) { + mt(function () { cb(a, b); }); + }; + mt(function () { cbd = cb; }); + var cbf = function () { + var out = new u8(tot + 22), oe = o, cdl = tot - o; + tot = 0; + for (var i = 0; i < slft; ++i) { + var f = files[i]; + try { + var l = f.c.length; + wzh(out, tot, f, f.f, f.u, l); + var badd = 30 + f.f.length + exfl(f.extra); + var loc = tot + badd; + out.set(f.c, loc); + wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l; + } + catch (e) { + return cbd(e, null); + } + } + wzf(out, o, files.length, cdl, oe); + cbd(null, out); + }; + if (!lft) + cbf(); + var _loop_1 = function (i) { + var fn = k[i]; + var _a = r[fn], file = _a[0], p = _a[1]; + var c = crc(), size = file.length; + c.p(file); + var f = strToU8(fn), s = f.length; + var com = p.comment, m = com && strToU8(com), ms = m && m.length; + var exl = exfl(p.extra); + var compression = p.level == 0 ? 0 : 8; + var cbl = function (e, d) { + if (e) { + tAll(); + cbd(e, null); + } + else { + var l = d.length; + files[i] = mrg(p, { + size: size, + crc: c.d(), + c: d, + f: f, + m: m, + u: s != fn.length || (m && (com.length != ms)), + compression: compression + }); + o += 30 + s + exl + l; + tot += 76 + 2 * (s + exl) + (ms || 0) + l; + if (!--lft) + cbf(); + } + }; + if (s > 65535) + cbl(err(11, 0, 1), null); + if (!compression) + cbl(null, file); + else if (size < 160000) { + try { + cbl(null, deflateSync(file, p)); + } + catch (e) { + cbl(e, null); + } + } + else + term.push(deflate(file, p, cbl)); + }; + // Cannot use lft because it can decrease + for (var i = 0; i < slft; ++i) { + _loop_1(i); + } + return tAll; +} +/** + * Synchronously creates a ZIP file. Prefer using `zip` for better performance + * with more than one file. + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @returns The generated ZIP archive + */ +export function zipSync(data, opts) { + if (!opts) + opts = {}; + var r = {}; + var files = []; + fltn(data, '', r, opts); + var o = 0; + var tot = 0; + for (var fn in r) { + var _a = r[fn], file = _a[0], p = _a[1]; + var compression = p.level == 0 ? 0 : 8; + var f = strToU8(fn), s = f.length; + var com = p.comment, m = com && strToU8(com), ms = m && m.length; + var exl = exfl(p.extra); + if (s > 65535) + err(11); + var d = compression ? deflateSync(file, p) : file, l = d.length; + var c = crc(); + c.p(file); + files.push(mrg(p, { + size: file.length, + crc: c.d(), + c: d, + f: f, + m: m, + u: s != fn.length || (m && (com.length != ms)), + o: o, + compression: compression + })); + o += 30 + s + exl + l; + tot += 76 + 2 * (s + exl) + (ms || 0) + l; + } + var out = new u8(tot + 22), oe = o, cdl = tot - o; + for (var i = 0; i < files.length; ++i) { + var f = files[i]; + wzh(out, f.o, f, f.f, f.u, f.c.length); + var badd = 30 + f.f.length + exfl(f.extra); + out.set(f.c, f.o + badd); + wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0); + } + wzf(out, o, files.length, cdl, oe); + return out; +} +/** + * Streaming pass-through decompression for ZIP archives + */ +var UnzipPassThrough = /*#__PURE__*/ (function () { + function UnzipPassThrough() { + } + UnzipPassThrough.prototype.push = function (chunk, final) { + // same as ZipPassThrough: cast to retain Buffer ergonomics + this.ondata(null, chunk, final); + }; + UnzipPassThrough.compression = 0; + return UnzipPassThrough; +}()); +export { UnzipPassThrough }; +/** + * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for + * better performance. + */ +var UnzipInflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + function UnzipInflate() { + var _this = this; + this.i = new Inflate(function (dat, final) { + _this.ondata(null, dat, final); + }); + } + UnzipInflate.prototype.push = function (chunk, final) { + try { + this.i.push(chunk, final); + } + catch (e) { + this.ondata(e, null, final); + } + }; + UnzipInflate.compression = 8; + return UnzipInflate; +}()); +export { UnzipInflate }; +/** + * Asynchronous streaming DEFLATE decompression for ZIP archives + */ +var AsyncUnzipInflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + function AsyncUnzipInflate(_, sz) { + var _this = this; + if (sz < 320000) { + this.i = new Inflate(function (dat, final) { + _this.ondata(null, dat, final); + }); + } + else { + this.i = new AsyncInflate(function (err, dat, final) { + _this.ondata(err, dat, final); + }); + this.terminate = this.i.terminate; + } + } + AsyncUnzipInflate.prototype.push = function (chunk, final) { + if (this.i.terminate) + chunk = slc(chunk, 0); + this.i.push(chunk, final); + }; + AsyncUnzipInflate.compression = 8; + return AsyncUnzipInflate; +}()); +export { AsyncUnzipInflate }; +/** + * A ZIP archive decompression stream that emits files as they are discovered + */ +var Unzip = /*#__PURE__*/ (function () { + /** + * Creates a ZIP decompression stream + * @param cb The callback to call whenever a file in the ZIP archive is found + */ + function Unzip(cb) { + this.onfile = cb; + this.k = []; + this.o = { + 0: UnzipPassThrough + }; + this.p = et; + } + /** + * Pushes a chunk to be unzipped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Unzip.prototype.push = function (chunk, final) { + var _this = this; + if (!this.onfile) + err(5); + if (!this.p) + err(4); + if (this.c > 0) { + var len = Math.min(this.c, chunk.length); + var toAdd = chunk.subarray(0, len); + this.c -= len; + if (this.d) + this.d.push(toAdd, !this.c); + else + this.k[0].push(toAdd); + chunk = chunk.subarray(len); + if (chunk.length) + return this.push(chunk, final); + } + else { + var f = 0, i = 0, is = void 0, buf = void 0; + if (!this.p.length) + buf = chunk; + else if (!chunk.length) + buf = this.p; + else { + buf = new u8(this.p.length + chunk.length); + buf.set(this.p), buf.set(chunk, this.p.length); + } + var l = buf.length, oc = this.c, add = oc && this.d; + var _loop_2 = function () { + var sig = b4(buf, i); + if (sig == 0x4034B50) { + f = 1, is = i; + this_1.d = null; + this_1.c = 0; + var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28); + if (l > i + 30 + fnl + es) { + var chks_3 = []; + this_1.k.unshift(chks_3); + f = 2; + var lsc = b4(buf, i + 18), lsu = b4(buf, i + 22); + var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u); + var _a = z64hs(buf, i, es, 2, lsc, lsu, 0), sc_1 = _a[0], su_1 = _a[1], z64 = _a[3]; + if (dd) + sc_1 = -1 - z64; + i += es; + this_1.c = sc_1; + var d_1; + var file_1 = { + name: fn_1, + compression: cmp_1, + start: function () { + if (!file_1.ondata) + err(5); + if (!sc_1) + file_1.ondata(null, et, true); + else { + var ctr = _this.o[cmp_1]; + if (!ctr) + file_1.ondata(err(14, 'unknown compression type ' + cmp_1, 1), null, false); + d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1); + d_1.ondata = function (err, dat, final) { file_1.ondata(err, dat, final); }; + for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) { + var dat = chks_4[_i]; + d_1.push(dat, false); + } + if (_this.k[0] == chks_3 && _this.c) + _this.d = d_1; + else + d_1.push(et, true); + } + }, + terminate: function () { + if (d_1 && d_1.terminate) + d_1.terminate(); + } + }; + if (sc_1 >= 0) + file_1.size = sc_1, file_1.originalSize = su_1; + this_1.onfile(file_1); + } + return "break"; + } + else if (oc) { + if (sig == 0x8074B50) { + is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0; + return "break"; + } + else if (sig == 0x2014B50) { + is = i -= 4, f = 3, this_1.c = 0; + return "break"; + } + } + }; + var this_1 = this; + for (; i < l - 4; ++i) { + var state_1 = _loop_2(); + if (state_1 === "break") + break; + } + this.p = et; + if (oc < 0) { + var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 0x8074B50 && 4)) : buf.subarray(0, i); + if (add) + add.push(dat, !!f); + else + this.k[+(f == 2)].push(dat); + } + if (f & 2) + return this.push(buf.subarray(i), final); + this.p = buf.subarray(i); + } + if (final) { + if (this.c) + err(13); + this.p = null; + } + }; + /** + * Registers a decoder with the stream, allowing for files compressed with + * the compression type provided to be expanded correctly + * @param decoder The decoder constructor + */ + Unzip.prototype.register = function (decoder) { + this.o[decoder.compression] = decoder; + }; + return Unzip; +}()); +export { Unzip }; +var mt = typeof queueMicrotask == 'function' ? queueMicrotask : typeof setTimeout == 'function' ? setTimeout : function (fn) { fn(); }; +export function unzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + var term = []; + var tAll = function () { + for (var i = 0; i < term.length; ++i) + term[i](); + }; + var files = {}; + var cbd = function (a, b) { + mt(function () { cb(a, b); }); + }; + mt(function () { cbd = cb; }); + var e = data.length - 22; + for (; b4(data, e) != 0x6054B50; --e) { + if (!e || data.length - e > 65558) { + cbd(err(13, 0, 1), null); + return tAll; + } + } + ; + var lft = b2(data, e + 8); + if (lft) { + var c = lft; + var o = b4(data, e + 16); + var z = b4(data, e - 20) == 0x7064B50; + if (z) { + var ze = b4(data, e - 12); + z = b4(data, ze) == 0x6064B50; + if (z) { + c = lft = b4(data, ze + 32); + o = b4(data, ze + 48); + } + } + var fltr = opts && opts.filter; + var _loop_3 = function (i) { + var _a = zh(data, o, z), c_1 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off); + o = no; + var cbl = function (e, d) { + if (e) { + tAll(); + cbd(e, null); + } + else { + if (d) + files[fn] = d; + if (!--lft) + cbd(null, files); + } + }; + if (!fltr || fltr({ + name: fn, + size: sc, + originalSize: su, + compression: c_1 + })) { + if (!c_1) + cbl(null, slc(data, b, b + sc)); + else if (c_1 == 8) { + var infl = data.subarray(b, b + sc); + // Synchronously decompress under 512KB, or barely-compressed data + if (su < 524288 || sc > 0.8 * su) { + try { + cbl(null, inflateSync(infl, { out: new u8(su) })); + } + catch (e) { + cbl(e, null); + } + } + else + term.push(inflate(infl, { size: su }, cbl)); + } + else + cbl(err(14, 'unknown compression type ' + c_1, 1), null); + } + else + cbl(null, null); + }; + for (var i = 0; i < c; ++i) { + _loop_3(i); + } + } + else + cbd(null, {}); + return tAll; +} +/** + * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better + * performance with more than one file. + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @returns The decompressed files + */ +export function unzipSync(data, opts) { + var files = {}; + var e = data.length - 22; + for (; b4(data, e) != 0x6054B50; --e) { + if (!e || data.length - e > 65558) + err(13); + } + ; + var c = b2(data, e + 8); + if (!c) + return {}; + var o = b4(data, e + 16); + var z = b4(data, e - 20) == 0x7064B50; + if (z) { + var ze = b4(data, e - 12); + z = b4(data, ze) == 0x6064B50; + if (z) { + c = b4(data, ze + 32); + o = b4(data, ze + 48); + } + } + var fltr = opts && opts.filter; + for (var i = 0; i < c; ++i) { + var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off); + o = no; + if (!fltr || fltr({ + name: fn, + size: sc, + originalSize: su, + compression: c_2 + })) { + if (!c_2) + files[fn] = slc(data, b, b + sc); + else if (c_2 == 8) + files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) }); + else + err(14, 'unknown compression type ' + c_2); + } + } + return files; +} diff --git a/tools/ui/node_modules/fflate/esm/index.d.mts b/tools/ui/node_modules/fflate/esm/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..d430faf2b555c978d66c89f46155b72c2c45a971 --- /dev/null +++ b/tools/ui/node_modules/fflate/esm/index.d.mts @@ -0,0 +1,1539 @@ +/** + * Codes for errors generated within this library + */ +export declare const FlateErrorCode: { + readonly UnexpectedEOF: 0; + readonly InvalidBlockType: 1; + readonly InvalidLengthLiteral: 2; + readonly InvalidDistance: 3; + readonly StreamFinished: 4; + readonly NoStreamHandler: 5; + readonly InvalidHeader: 6; + readonly NoCallback: 7; + readonly InvalidUTF8: 8; + readonly ExtraFieldTooLong: 9; + readonly InvalidDate: 10; + readonly FilenameTooLong: 11; + readonly StreamFinishing: 12; + readonly InvalidZipData: 13; + readonly UnknownCompressionMethod: 14; +}; +/** + * An error generated within this library + */ +export interface FlateError extends Error { + /** + * The code associated with this error + */ + code: number; +} +/** + * Options for decompressing a DEFLATE stream + */ +export interface InflateStreamOptions { + /** + * The dictionary used to compress the original data. If no dictionary was used during compression, this option has no effect. + * + * Supplying the wrong dictionary during decompression usually yields corrupt output or causes an invalid distance error. + */ + dictionary?: Uint8Array; +} +/** + * Options for decompressing DEFLATE data + */ +export interface InflateOptions extends InflateStreamOptions { + /** + * The buffer into which to write the decompressed data. Saves memory if you know the decompressed size in advance. + * + * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit. + */ + out?: Uint8Array; +} +/** + * Options for decompressing a GZIP stream + */ +export interface GunzipStreamOptions extends InflateStreamOptions { +} +/** + * Options for decompressing GZIP data + */ +export interface GunzipOptions extends InflateStreamOptions { + /** + * The buffer into which to write the decompressed data. GZIP already encodes the output size, so providing this doesn't save memory. + * + * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit. + */ + out?: Uint8Array; +} +/** + * Options for decompressing a Zlib stream + */ +export interface UnzlibStreamOptions extends InflateStreamOptions { +} +/** + * Options for decompressing Zlib data + */ +export interface UnzlibOptions extends InflateOptions { +} +/** + * Options for compressing data into a DEFLATE format + */ +export interface DeflateOptions { + /** + * The level of compression to use, ranging from 0-9. + * + * 0 will store the data without compression. + * 1 is fastest but compresses the worst, 9 is slowest but compresses the best. + * The default level is 6. + * + * Typically, binary data benefits much more from higher values than text data. + * In both cases, higher values usually take disproportionately longer than the reduction in final size that results. + * + * For example, a 1 MB text file could: + * - become 1.01 MB with level 0 in 1ms + * - become 400 kB with level 1 in 10ms + * - become 320 kB with level 9 in 100ms + */ + level?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + /** + * The memory level to use, ranging from 0-12. Increasing this increases speed and compression ratio at the cost of memory. + * + * Note that this is exponential: while level 0 uses 8 kB, level 4 uses 128 kB, level 8 uses 2 MB, and level 12 uses 32 MB. + * It is recommended not to lower the value below 4, since that tends to hurt performance. + * In addition, values above 8 tend to help very little on most data and can even hurt performance. + * + * The default value is automatically determined based on the size of the input data. + */ + mem?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12; + /** + * A buffer containing common byte sequences in the input data that can be used to significantly improve compression ratios. + * + * Dictionaries should be 32kB or smaller and include strings or byte sequences likely to appear in the input. + * The decompressor must supply the same dictionary as the compressor to extract the original data. + * + * Dictionaries only improve aggregate compression ratio when reused across multiple small inputs. They should typically not be used otherwise. + * + * Avoid using dictionaries with GZIP and ZIP to maximize software compatibility. + */ + dictionary?: Uint8Array; +} +/** + * Options for compressing data into a GZIP format + */ +export interface GzipOptions extends DeflateOptions { + /** + * When the file was last modified. Defaults to the current time. + * Set this to 0 to avoid revealing a modification date entirely. + */ + mtime?: Date | string | number; + /** + * The filename of the data. If the `gunzip` command is used to decompress the data, it will output a file + * with this name instead of the name of the compressed file. + */ + filename?: string; +} +/** + * Options for compressing data into a Zlib format + */ +export interface ZlibOptions extends DeflateOptions { +} +/** + * Handler for data (de)compression streams + * @param data The data output from the stream processor + * @param final Whether this is the final block + */ +export type FlateStreamHandler = (data: Uint8Array, final: boolean) => void; +/** + * Handler for asynchronous data (de)compression streams + * @param err Any error that occurred + * @param data The data output from the stream processor + * @param final Whether this is the final block + */ +export type AsyncFlateStreamHandler = (err: FlateError | null, data: Uint8Array, final: boolean) => void; +/** + * Handler for the asynchronous completion of (de)compression for a data chunk + * @param size The number of bytes that were processed. This is measured in terms of the input + * (i.e. compressed bytes for decompression, uncompressed bytes for compression.) + */ +export type AsyncFlateDrainHandler = (size: number) => void; +/** + * Callback for asynchronous (de)compression methods + * @param err Any error that occurred + * @param data The resulting data. Only present if `err` is null + */ +export type FlateCallback = (err: FlateError | null, data: Uint8Array) => void; +interface AsyncOptions { + /** + * Whether or not to "consume" the source data. This will make the typed array/buffer you pass in + * unusable but will increase performance and reduce memory usage. + */ + consume?: boolean; +} +/** + * Options for compressing data asynchronously into a DEFLATE format + */ +export interface AsyncDeflateOptions extends DeflateOptions, AsyncOptions { +} +/** + * Options for decompressing DEFLATE data asynchronously + */ +export interface AsyncInflateOptions extends AsyncOptions, InflateStreamOptions { + /** + * The original size of the data. Currently, the asynchronous API disallows + * writing into a buffer you provide; the best you can do is provide the + * size in bytes and be given back a new typed array. + */ + size?: number; +} +/** + * Options for compressing data asynchronously into a GZIP format + */ +export interface AsyncGzipOptions extends GzipOptions, AsyncOptions { +} +/** + * Options for decompressing GZIP data asynchronously + */ +export interface AsyncGunzipOptions extends AsyncOptions, InflateStreamOptions { +} +/** + * Options for compressing data asynchronously into a Zlib format + */ +export interface AsyncZlibOptions extends ZlibOptions, AsyncOptions { +} +/** + * Options for decompressing Zlib data asynchronously + */ +export interface AsyncUnzlibOptions extends AsyncInflateOptions { +} +/** + * A terminable compression/decompression process + */ +export interface AsyncTerminable { + /** + * Terminates the worker thread immediately. The callback will not be called. + */ + (): void; +} +/** + * Streaming DEFLATE compression + */ +export declare class Deflate { + /** + * Creates a DEFLATE stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: DeflateOptions, cb?: FlateStreamHandler); + /** + * Creates a DEFLATE stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + private b; + private s; + private o; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + private p; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE compression + */ +export declare class AsyncDeflate { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous DEFLATE stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: DeflateOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous DEFLATE stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function deflate(data: Uint8Array, opts: AsyncDeflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param cb The function to be called upon compression completion + */ +export declare function deflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @returns The deflated version of the data + */ +export declare function deflateSync(data: Uint8Array, opts?: DeflateOptions): Uint8Array; +/** + * Streaming DEFLATE decompression + */ +export declare class Inflate { + private s; + private o; + private p; + private d; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a DEFLATE decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: InflateStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a DEFLATE decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + private e; + private c; + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the final chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE decompression + */ +export declare class AsyncInflate { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous DEFLATE decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: InflateStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous DEFLATE decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function inflate(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function inflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands DEFLATE data with no wrapper + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function inflateSync(data: Uint8Array): Uint8Array; +/** + * Expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function inflateSync(data: Uint8Array, opts?: InflateOptions): Uint8Array; +/** + * Streaming GZIP compression + */ +export declare class Gzip { + private c; + private l; + private v; + private o; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a GZIP stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: GzipOptions, cb?: FlateStreamHandler); + /** + * Creates a GZIP stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + private p; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming GZIP compression + */ +export declare class AsyncGzip { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous GZIP stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: GzipOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous GZIP stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function gzip(data: Uint8Array, opts: AsyncGzipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with GZIP + * @param data The data to compress + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @returns The gzipped version of the data + */ +export declare function gzipSync(data: Uint8Array, opts?: GzipOptions): Uint8Array; +/** + * Handler for new GZIP members in concatenated GZIP streams. Useful for building indices used to perform random-access reads on compressed files. + * @param offset The offset of the new member relative to the start of the stream + */ +export type GunzipMemberHandler = (offset: number) => void; +/** + * Streaming single or multi-member GZIP decompression + */ +export declare class Gunzip { + private v; + private r; + private o; + private p; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * The handler to call whenever a new GZIP member is found + */ + onmember?: GunzipMemberHandler; + /** + * Creates a GUNZIP stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: GunzipStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a GUNZIP stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming single or multi-member GZIP decompression + */ +export declare class AsyncGunzip { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * The handler to call whenever a new GZIP member is found + */ + onmember?: GunzipMemberHandler; + /** + * Creates an asynchronous GUNZIP stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: GunzipStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous GUNZIP stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands GZIP data + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gunzip(data: Uint8Array, opts: AsyncGunzipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands GZIP data + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gunzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands GZIP data + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function gunzipSync(data: Uint8Array): Uint8Array; +/** + * Expands GZIP data + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function gunzipSync(data: Uint8Array, opts?: GunzipOptions): Uint8Array; +/** + * Streaming Zlib compression + */ +export declare class Zlib { + private c; + private v; + private o; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a Zlib stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: ZlibOptions, cb?: FlateStreamHandler); + /** + * Creates a Zlib stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be zlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + private p; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming Zlib compression + */ +export declare class AsyncZlib { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous Zlib stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: ZlibOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous Zlib stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with Zlib + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + */ +export declare function zlib(data: Uint8Array, opts: AsyncZlibOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with Zlib + * @param data The data to compress + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compress data with Zlib + * @param data The data to compress + * @param opts The compression options + * @returns The zlib-compressed version of the data + */ +export declare function zlibSync(data: Uint8Array, opts?: ZlibOptions): Uint8Array; +/** + * Streaming Zlib decompression + */ +export declare class Unzlib { + private v; + private p; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a Zlib decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: UnzlibStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a Zlib decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be unzlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming Zlib decompression + */ +export declare class AsyncUnzlib { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous Zlib decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: UnzlibStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous Zlib decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be decompressed from Zlib + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands Zlib data + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function unzlib(data: Uint8Array, opts: AsyncUnzlibOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands Zlib data + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function unzlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands Zlib data + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function unzlibSync(data: Uint8Array): Uint8Array; +/** + * Expands Zlib data + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function unzlibSync(data: Uint8Array, opts?: UnzlibOptions): Uint8Array; +export { gzip as compress, AsyncGzip as AsyncCompress }; +export { gzipSync as compressSync, Gzip as Compress }; +/** + * Streaming GZIP, Zlib, or raw DEFLATE decompression + */ +export declare class Decompress { + private G; + private I; + private Z; + private o; + private s; + private p; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is decompressed + */ + constructor(opts: InflateStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a decompression stream + * @param cb The callback to call whenever data is decompressed + */ + constructor(cb?: FlateStreamHandler); + private i; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression + */ +export declare class AsyncDecompress { + private G; + private I; + private Z; + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is decompressed + */ + constructor(opts: InflateStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous decompression stream + * @param cb The callback to call whenever data is decompressed + */ + constructor(cb?: AsyncFlateStreamHandler); + private i; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function decompress(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function decompress(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function decompressSync(data: Uint8Array, opts?: InflateOptions): Uint8Array; +/** + * Attributes for files added to a ZIP archive object + */ +export interface ZipAttributes { + /** + * The operating system of origin for this file. The value is defined + * by PKZIP's APPNOTE.txt, section 4.4.2.2. For example, 0 (the default) + * is MS/DOS, 3 is Unix, 19 is macOS. + */ + os?: number; + /** + * The file's attributes. These are traditionally somewhat complicated + * and platform-dependent, so using them is scarcely necessary. However, + * here is a representation of what this is, bit by bit: + * + * `TTTTugtrwxrwxrwx0000000000ADVSHR` + * + * TTTT = file type (rarely useful) + * + * u = setuid, g = setgid, t = sticky + * + * rwx = user permissions, rwx = group permissions, rwx = other permissions + * + * 0000000000 = unused + * + * A = archive, D = directory, V = volume label, S = system file, H = hidden, R = read-only + * + * If you want to set the Unix permissions, for instance, just bit shift by 16, e.g. 0o644 << 16. + * Note that attributes usually only work in conjunction with the `os` setting: you must use + * `os` = 3 (Unix) if you want to set Unix permissions + */ + attrs?: number; + /** + * Extra metadata to add to the file. This field is defined by PKZIP's APPNOTE.txt, + * section 4.4.28. At most 65,535 bytes may be used in each ID. The ID must be an + * integer between 0 and 65,535, inclusive. + * + * This field is incredibly rare and almost never needed except for compliance with + * proprietary standards and software. + */ + extra?: Record; + /** + * The comment to attach to the file. This field is defined by PKZIP's APPNOTE.txt, + * section 4.4.26. The comment must be at most 65,535 bytes long UTF-8 encoded. This + * field is not read by consumer software. + */ + comment?: string; + /** + * When the file was last modified. Defaults to the current time. + */ + mtime?: GzipOptions['mtime']; +} +/** + * Options for creating a ZIP archive + */ +export interface ZipOptions extends DeflateOptions, ZipAttributes { +} +/** + * Options for expanding a ZIP archive + */ +export interface UnzipOptions { + /** + * A filter function to extract only certain files from a ZIP archive + */ + filter?: UnzipFileFilter; +} +/** + * Options for asynchronously creating a ZIP archive + */ +export interface AsyncZipOptions extends AsyncDeflateOptions, ZipAttributes { +} +/** + * Options for asynchronously expanding a ZIP archive + */ +export interface AsyncUnzipOptions extends UnzipOptions { +} +/** + * A file that can be used to create a ZIP archive + */ +export type ZippableFile = Uint8Array | Zippable | [Uint8Array | Zippable, ZipOptions]; +/** + * A file that can be used to asynchronously create a ZIP archive + */ +export type AsyncZippableFile = Uint8Array | AsyncZippable | [Uint8Array | AsyncZippable, AsyncZipOptions]; +/** + * The complete directory structure of a ZIPpable archive + */ +export interface Zippable { + [path: string]: ZippableFile; +} +/** + * The complete directory structure of an asynchronously ZIPpable archive + */ +export interface AsyncZippable { + [path: string]: AsyncZippableFile; +} +/** + * An unzipped archive. The full path of each file is used as the key, + * and the file is the value + */ +export interface Unzipped { + [path: string]: Uint8Array; +} +/** + * Handler for string generation streams + * @param data The string output from the stream processor + * @param final Whether this is the final block + */ +export type StringStreamHandler = (data: string, final: boolean) => void; +/** + * Callback for asynchronous ZIP decompression + * @param err Any error that occurred + * @param data The decompressed ZIP archive + */ +export type UnzipCallback = (err: FlateError | null, data: Unzipped) => void; +/** + * Handler for streaming ZIP decompression + * @param file The file that was found in the archive + */ +export type UnzipFileHandler = (file: UnzipFile) => void; +/** + * Streaming UTF-8 decoding + */ +export declare class DecodeUTF8 { + private p; + private t; + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is decoded + */ + constructor(cb?: StringStreamHandler); + /** + * Pushes a chunk to be decoded from UTF-8 binary + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * The handler to call whenever data is available + */ + ondata: StringStreamHandler; +} +/** + * Streaming UTF-8 encoding + */ +export declare class EncodeUTF8 { + private d; + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is encoded + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be encoded to UTF-8 + * @param chunk The string data to push + * @param final Whether this is the last chunk + */ + push(chunk: string, final?: boolean): void; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; +} +/** + * Converts a string into a Uint8Array for use with compression/decompression methods + * @param str The string to encode + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless decoding a binary string. + * @returns The string encoded in UTF-8/Latin-1 binary + */ +export declare function strToU8(str: string, latin1?: boolean): Uint8Array; +/** + * Converts a Uint8Array to a string + * @param dat The data to decode to string + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless encoding to binary string. + * @returns The original UTF-8/Latin-1 string + */ +export declare function strFromU8(dat: Uint8Array, latin1?: boolean): string; +/** + * A stream that can be used to create a file in a ZIP archive + */ +export interface ZipInputFile extends ZipAttributes { + /** + * The filename to associate with the data provided to this stream. If you + * want a file in a subdirectory, use forward slashes as a separator (e.g. + * `directory/filename.ext`). This will still work on Windows. + */ + filename: string; + /** + * The size of the file in bytes. This attribute may be invalid after + * the file is added to the ZIP archive; it must be correct only before the + * stream completes. + * + * If you don't want to have to compute this yourself, consider extending the + * ZipPassThrough class and overriding its process() method, or using one of + * ZipDeflate or AsyncZipDeflate. + */ + size: number; + /** + * A CRC of the original file contents. This attribute may be invalid after + * the file is added to the ZIP archive; it must be correct only before the + * stream completes. + * + * If you don't want to have to generate this yourself, consider extending the + * ZipPassThrough class and overriding its process() method, or using one of + * ZipDeflate or AsyncZipDeflate. + */ + crc: number; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA + */ + compression: number; + /** + * Bits 1 and 2 of the general purpose bit flag, specified in PKZIP's + * APPNOTE.txt, section 4.4.4. Should be between 0 and 3. This is unlikely + * to be necessary. + */ + flag?: number; + /** + * The handler to be called when data is added. After passing this stream to + * the ZIP file object, this handler will always be defined. To call it: + * + * `stream.ondata(error, chunk, final)` + * + * error = any error that occurred (null if there was no error) + * + * chunk = a Uint8Array of the data that was added (null if there was an + * error) + * + * final = boolean, whether this is the final chunk in the stream + */ + ondata?: AsyncFlateStreamHandler; + /** + * A method called when the stream is no longer needed, for clean-up + * purposes. This will not always be called after the stream completes, + * so you may wish to call this.terminate() after the final chunk is + * processed if you have clean-up logic. + */ + terminate?: AsyncTerminable; +} +/** + * A pass-through stream to keep data uncompressed in a ZIP archive. + */ +export declare class ZipPassThrough implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private c; + /** + * Creates a pass-through stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + */ + constructor(filename: string); + /** + * Processes a chunk and pushes to the output stream. You can override this + * method in a subclass for custom behavior, but by default this passes + * the data through. You must call this.ondata(err, chunk, final) at some + * point in this method. + * @param chunk The chunk to process + * @param final Whether this is the last chunk + */ + protected process(chunk: Uint8Array, final: boolean): void; + /** + * Pushes a chunk to be added. If you are subclassing this with a custom + * compression algorithm, note that you must push data from the source + * file only, pre-compression. + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate + * for better performance + */ +export declare class ZipDeflate implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + flag: 0 | 1 | 2 | 3; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private d; + /** + * Creates a DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + constructor(filename: string, opts?: DeflateOptions); + private process; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE compression for ZIP archives + */ +export declare class AsyncZipDeflate implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + flag: 0 | 1 | 2 | 3; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private d; + terminate: AsyncTerminable; + /** + * Creates an asynchronous DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + constructor(filename: string, opts?: DeflateOptions); + private process; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * A zippable archive to which files can incrementally be added + */ +export declare class Zip { + private u; + private d; + /** + * Creates an empty ZIP archive to which files can be added + * @param cb The callback to call whenever data for the generated ZIP archive + * is available + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Adds a file to the ZIP archive + * @param file The file stream to add + */ + add(file: ZipInputFile): void; + /** + * Ends the process of adding files and prepares to emit the final chunks. + * This *must* be called after adding all desired files for the resulting + * ZIP file to work properly. + */ + end(): void; + private e; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to add() will fail. + */ + terminate(): void; + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; +} +/** + * Asynchronously creates a ZIP file + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @param cb The callback to call with the generated ZIP archive + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zip(data: AsyncZippable, opts: AsyncZipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously creates a ZIP file + * @param data The directory structure for the ZIP archive + * @param cb The callback to call with the generated ZIP archive + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zip(data: AsyncZippable, cb: FlateCallback): AsyncTerminable; +/** + * Synchronously creates a ZIP file. Prefer using `zip` for better performance + * with more than one file. + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @returns The generated ZIP archive + */ +export declare function zipSync(data: Zippable, opts?: ZipOptions): Uint8Array; +/** + * A decoder for files in ZIP streams + */ +export interface UnzipDecoder { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * Pushes a chunk to be decompressed + * @param chunk The data in this chunk. Do not consume (detach) this buffer. + * @param final Whether this is the last chunk in the data stream + */ + push(chunk: Uint8Array, final: boolean): void; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to push() should silently fail. + */ + terminate?: AsyncTerminable; +} +/** + * A constructor for a decoder for unzip streams + */ +export interface UnzipDecoderConstructor { + /** + * Creates an instance of the decoder + * @param filename The name of the file + * @param size The compressed size of the file + * @param originalSize The original size of the file + */ + new (filename: string, size?: number, originalSize?: number): UnzipDecoder; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA + */ + compression: number; +} +/** + * Information about a file to be extracted from a ZIP archive + */ +export interface UnzipFileInfo { + /** + * The name of the file + */ + name: string; + /** + * The compressed size of the file + */ + size: number; + /** + * The original size of the file + */ + originalSize: number; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA. If the filter function returns true + * but this value is not 8, the unzip function will throw. + */ + compression: number; +} +/** + * A filter for files to be extracted during the unzipping process + * @param file The info for the current file being processed + * @returns Whether or not to extract the current file + */ +export type UnzipFileFilter = (file: UnzipFileInfo) => boolean; +/** + * Streaming file extraction from ZIP archives + */ +export interface UnzipFile { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The name of the file + */ + name: string; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA. If start() is called but there is no + * decompression stream available for this method, start() will throw. + */ + compression: number; + /** + * The compressed size of the file. Will not be present for archives created + * in a streaming fashion. + */ + size?: number; + /** + * The original size of the file. Will not be present for archives created + * in a streaming fashion. + */ + originalSize?: number; + /** + * Starts reading from the stream. Calling this function will always enable + * this stream, but ocassionally the stream will be enabled even without + * this being called. + */ + start(): void; + /** + * A method to terminate any internal workers used by the stream. ondata + * will not be called any further. + */ + terminate: AsyncTerminable; +} +/** + * Streaming pass-through decompression for ZIP archives + */ +export declare class UnzipPassThrough implements UnzipDecoder { + static compression: number; + ondata: AsyncFlateStreamHandler; + push(chunk: Uint8Array, final: boolean): void; +} +/** + * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for + * better performance. + */ +export declare class UnzipInflate implements UnzipDecoder { + static compression: number; + private i; + ondata: AsyncFlateStreamHandler; + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + constructor(); + push(chunk: Uint8Array, final: boolean): void; +} +/** + * Asynchronous streaming DEFLATE decompression for ZIP archives + */ +export declare class AsyncUnzipInflate implements UnzipDecoder { + static compression: number; + private i; + ondata: AsyncFlateStreamHandler; + terminate: AsyncTerminable; + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + constructor(_: string, sz?: number); + push(chunk: Uint8Array, final: boolean): void; +} +/** + * A ZIP archive decompression stream that emits files as they are discovered + */ +export declare class Unzip { + private d; + private c; + private p; + private k; + private o; + /** + * Creates a ZIP decompression stream + * @param cb The callback to call whenever a file in the ZIP archive is found + */ + constructor(cb?: UnzipFileHandler); + /** + * Pushes a chunk to be unzipped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Registers a decoder with the stream, allowing for files compressed with + * the compression type provided to be expanded correctly + * @param decoder The decoder constructor + */ + register(decoder: UnzipDecoderConstructor): void; + /** + * The handler to call whenever a file is discovered + */ + onfile: UnzipFileHandler; +} +/** + * Asynchronously decompresses a ZIP archive + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @param cb The callback to call with the decompressed files + * @returns A function that can be used to immediately terminate the unzipping + */ +export declare function unzip(data: Uint8Array, opts: AsyncUnzipOptions, cb: UnzipCallback): AsyncTerminable; +/** + * Asynchronously decompresses a ZIP archive + * @param data The raw compressed ZIP file + * @param cb The callback to call with the decompressed files + * @returns A function that can be used to immediately terminate the unzipping + */ +export declare function unzip(data: Uint8Array, cb: UnzipCallback): AsyncTerminable; +/** + * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better + * performance with more than one file. + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @returns The decompressed files + */ +export declare function unzipSync(data: Uint8Array, opts?: UnzipOptions): Unzipped; diff --git a/tools/ui/node_modules/fflate/esm/index.mjs b/tools/ui/node_modules/fflate/esm/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..4c057eef8a9932d1eb80325c2f08f2975afe23bd --- /dev/null +++ b/tools/ui/node_modules/fflate/esm/index.mjs @@ -0,0 +1,2710 @@ +import { createRequire } from 'module'; +var require = createRequire('/'); +// DEFLATE is a complex format; to read this code, you should probably check the RFC first: +// https://tools.ietf.org/html/rfc1951 +// You may also wish to take a look at the guide I made about this program: +// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad +// Some of the following code is similar to that of UZIP.js: +// https://github.com/photopea/UZIP.js +// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size. +// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint +// is better for memory in most engines (I *think*). +var _a; +// Mediocre shim +var Worker; +var isMarkedAsUntransferable; +var workerAdd = ";var __w=require('worker_threads');__w.parentPort.on('message',function(m){onmessage({data:m})}),postMessage=function(m,t){__w.parentPort.postMessage(m,t)},close=process.exit;self=global"; +try { + (_a = require('worker_threads'), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable); +} +catch (e) { +} +var wk = Worker ? function (c, _, msg, transfer, cb) { + var done = false; + var w = new Worker(c + workerAdd, { eval: true }) + .on('error', function (e) { return cb(e, null); }) + .on('message', function (m) { return cb(null, m); }) + .on('exit', function (c) { + if (c && !done) + cb(new Error('exited with code ' + c), null); + }); + if (isMarkedAsUntransferable) + transfer = transfer.filter(function (t) { return !isMarkedAsUntransferable(t); }); + w.postMessage(msg, transfer); + w.terminate = function () { + done = true; + return Worker.prototype.terminate.call(w); + }; + return w; +} : function (_, __, ___, ____, cb) { + setImmediate(function () { return cb(new Error('async operations unsupported - update to Node 12+ (or Node 10-11 with the --experimental-worker CLI flag)'), null); }); + var NOP = function () { }; + return { + terminate: NOP, + postMessage: NOP + }; +}; + +// aliases for shorter compressed code (most minifers don't do this) +var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array; +// fixed length extra bits +var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]); +// fixed distance extra bits +var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]); +// code length index map +var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]); +// get base, reverse index map from extra bits +var freb = function (eb, start) { + var b = new u16(31); + for (var i = 0; i < 31; ++i) { + b[i] = start += 1 << eb[i - 1]; + } + // numbers here are at max 18 bits + var r = new i32(b[30]); + for (var i = 1; i < 30; ++i) { + for (var j = b[i]; j < b[i + 1]; ++j) { + r[j] = ((j - b[i]) << 5) | i; + } + } + return { b: b, r: r }; +}; +var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r; +// we can ignore the fact that the other numbers are wrong; they never happen anyway +fl[28] = 258, revfl[258] = 28; +var _b = freb(fdeb, 0), fd = _b.b, revfd = _b.r; +// map of value to reverse (assuming 16 bits) +var rev = new u16(32768); +for (var i = 0; i < 32768; ++i) { + // reverse table algorithm from SO + var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1); + x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2); + x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4); + rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1; +} +// create huffman tree from u8 "map": index -> code length for code index +// mb (max bits) must be at most 15 +// TODO: optimize/split up? +var hMap = (function (cd, mb, r) { + var s = cd.length; + // index + var i = 0; + // u16 "map": index -> # of codes with bit length = index + var l = new u16(mb); + // length of cd must be 288 (total # of codes) + for (; i < s; ++i) { + if (cd[i]) + ++l[cd[i] - 1]; + } + // u16 "map": index -> minimum code for bit length = index + var le = new u16(mb); + for (i = 1; i < mb; ++i) { + le[i] = (le[i - 1] + l[i - 1]) << 1; + } + var co; + if (r) { + // u16 "map": index -> number of actual bits, symbol for code + co = new u16(1 << mb); + // bits to remove for reverser + var rvb = 15 - mb; + for (i = 0; i < s; ++i) { + // ignore 0 lengths + if (cd[i]) { + // num encoding both symbol and bits read + var sv = (i << 4) | cd[i]; + // free bits + var r_1 = mb - cd[i]; + // start value + var v = le[cd[i] - 1]++ << r_1; + // m is end value + for (var m = v | ((1 << r_1) - 1); v <= m; ++v) { + // every 16 bit value starting with the code yields the same result + co[rev[v] >> rvb] = sv; + } + } + } + } + else { + co = new u16(s); + for (i = 0; i < s; ++i) { + if (cd[i]) { + co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]); + } + } + } + return co; +}); +// fixed length tree +var flt = new u8(288); +for (var i = 0; i < 144; ++i) + flt[i] = 8; +for (var i = 144; i < 256; ++i) + flt[i] = 9; +for (var i = 256; i < 280; ++i) + flt[i] = 7; +for (var i = 280; i < 288; ++i) + flt[i] = 8; +// fixed distance tree +var fdt = new u8(32); +for (var i = 0; i < 32; ++i) + fdt[i] = 5; +// fixed length map +var flm = /*#__PURE__*/ hMap(flt, 9, 0), flrm = /*#__PURE__*/ hMap(flt, 9, 1); +// fixed distance map +var fdm = /*#__PURE__*/ hMap(fdt, 5, 0), fdrm = /*#__PURE__*/ hMap(fdt, 5, 1); +// find max of array +var max = function (a) { + var m = a[0]; + for (var i = 1; i < a.length; ++i) { + if (a[i] > m) + m = a[i]; + } + return m; +}; +// read d, starting at bit p and mask with m +var bits = function (d, p, m) { + var o = (p / 8) | 0; + return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m; +}; +// read d, starting at bit p continuing for at least 16 bits +var bits16 = function (d, p) { + var o = (p / 8) | 0; + return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7)); +}; +// get end of byte +var shft = function (p) { return ((p + 7) / 8) | 0; }; +// typed array slice - allows garbage collector to free original reference, +// while being more compatible than .slice +var slc = function (v, s, e) { + if (s == null || s < 0) + s = 0; + if (e == null || e > v.length) + e = v.length; + // can't use .constructor in case user-supplied + return new u8(v.subarray(s, e)); +}; +/** + * Codes for errors generated within this library + */ +export var FlateErrorCode = { + UnexpectedEOF: 0, + InvalidBlockType: 1, + InvalidLengthLiteral: 2, + InvalidDistance: 3, + StreamFinished: 4, + NoStreamHandler: 5, + InvalidHeader: 6, + NoCallback: 7, + InvalidUTF8: 8, + ExtraFieldTooLong: 9, + InvalidDate: 10, + FilenameTooLong: 11, + StreamFinishing: 12, + InvalidZipData: 13, + UnknownCompressionMethod: 14 +}; +// error codes +var ec = [ + 'unexpected EOF', + 'invalid block type', + 'invalid length/literal', + 'invalid distance', + 'stream finished', + 'no stream handler', + , // determined by compression function + 'no callback', + 'invalid UTF-8 data', + 'extra field too long', + 'date not in range 1980-2099', + 'filename too long', + 'stream finishing', + 'invalid zip data' + // determined by unknown compression method +]; +; +var err = function (ind, msg, nt) { + var e = new Error(msg || ec[ind]); + e.code = ind; + if (Error.captureStackTrace) + Error.captureStackTrace(e, err); + if (!nt) + throw e; + return e; +}; +// expands raw DEFLATE data +var inflt = function (dat, st, buf, dict) { + // source length dict length + var sl = dat.length, dl = dict ? dict.length : 0; + if (!sl || st.f && !st.l) + return buf || new u8(0); + var noBuf = !buf; + // have to estimate size + var resize = noBuf || st.i != 2; + // no state + var noSt = st.i; + // Assumes roughly 33% compression ratio average + if (noBuf) + buf = new u8(sl * 3); + // ensure buffer can fit at least l elements + var cbuf = function (l) { + var bl = buf.length; + // need to increase size to fit + if (l > bl) { + // Double or set to necessary, whichever is greater + var nbuf = new u8(Math.max(bl * 2, l)); + nbuf.set(buf); + buf = nbuf; + } + }; + // last chunk bitpos bytes + var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n; + // total bits + var tbts = sl * 8; + do { + if (!lm) { + // BFINAL - this is only 1 when last chunk is next + final = bits(dat, pos, 1); + // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman + var type = bits(dat, pos + 1, 3); + pos += 3; + if (!type) { + // go to end of byte boundary + var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l; + if (t > sl) { + if (noSt) + err(0); + break; + } + // ensure size + if (resize) + cbuf(bt + l); + // Copy over uncompressed data + buf.set(dat.subarray(s, t), bt); + // Get new bitpos, update byte count + st.b = bt += l, st.p = pos = t * 8, st.f = final; + continue; + } + else if (type == 1) + lm = flrm, dm = fdrm, lbt = 9, dbt = 5; + else if (type == 2) { + // literal lengths + var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4; + var tl = hLit + bits(dat, pos + 5, 31) + 1; + pos += 14; + // length+distance tree + var ldt = new u8(tl); + // code length tree + var clt = new u8(19); + for (var i = 0; i < hcLen; ++i) { + // use index map to get real code + clt[clim[i]] = bits(dat, pos + i * 3, 7); + } + pos += hcLen * 3; + // code lengths bits + var clb = max(clt), clbmsk = (1 << clb) - 1; + // code lengths map + var clm = hMap(clt, clb, 1); + for (var i = 0; i < tl;) { + var r = clm[bits(dat, pos, clbmsk)]; + // bits read + pos += r & 15; + // symbol + var s = r >> 4; + // code length to copy + if (s < 16) { + ldt[i++] = s; + } + else { + // copy count + var c = 0, n = 0; + if (s == 16) + n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1]; + else if (s == 17) + n = 3 + bits(dat, pos, 7), pos += 3; + else if (s == 18) + n = 11 + bits(dat, pos, 127), pos += 7; + while (n--) + ldt[i++] = c; + } + } + // length tree distance tree + var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit); + // max length bits + lbt = max(lt); + // max dist bits + dbt = max(dt); + lm = hMap(lt, lbt, 1); + dm = hMap(dt, dbt, 1); + } + else + err(1); + if (pos > tbts) { + if (noSt) + err(0); + break; + } + } + // Make sure the buffer can hold this + the largest possible addition + // Maximum chunk size (practically, theoretically infinite) is 2^17 + if (resize) + cbuf(bt + 131072); + var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1; + var lpos = pos; + for (;; lpos = pos) { + // bits read, code + var c = lm[bits16(dat, pos) & lms], sym = c >> 4; + pos += c & 15; + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (!c) + err(2); + if (sym < 256) + buf[bt++] = sym; + else if (sym == 256) { + lpos = pos, lm = null; + break; + } + else { + var add = sym - 254; + // no extra bits needed if less + if (sym > 264) { + // index + var i = sym - 257, b = fleb[i]; + add = bits(dat, pos, (1 << b) - 1) + fl[i]; + pos += b; + } + // dist + var d = dm[bits16(dat, pos) & dms], dsym = d >> 4; + if (!d) + err(3); + pos += d & 15; + var dt = fd[dsym]; + if (dsym > 3) { + var b = fdeb[dsym]; + dt += bits16(dat, pos) & (1 << b) - 1, pos += b; + } + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (resize) + cbuf(bt + 131072); + var end = bt + add; + if (bt < dt) { + var shift = dl - dt, dend = Math.min(dt, end); + if (shift + bt < 0) + err(3); + for (; bt < dend; ++bt) + buf[bt] = dict[shift + bt]; + } + for (; bt < end; ++bt) + buf[bt] = buf[bt - dt]; + } + } + st.l = lm, st.p = lpos, st.b = bt, st.f = final; + if (lm) + final = 1, st.m = lbt, st.d = dm, st.n = dbt; + } while (!final); + // don't reallocate for streams or user buffers + return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt); +}; +// starting at p, write the minimum number of bits that can hold v to d +var wbits = function (d, p, v) { + v <<= p & 7; + var o = (p / 8) | 0; + d[o] |= v; + d[o + 1] |= v >> 8; +}; +// starting at p, write the minimum number of bits (>8) that can hold v to d +var wbits16 = function (d, p, v) { + v <<= p & 7; + var o = (p / 8) | 0; + d[o] |= v; + d[o + 1] |= v >> 8; + d[o + 2] |= v >> 16; +}; +// creates code lengths from a frequency table +var hTree = function (d, mb) { + // Need extra info to make a tree + var t = []; + for (var i = 0; i < d.length; ++i) { + if (d[i]) + t.push({ s: i, f: d[i] }); + } + var s = t.length; + var t2 = t.slice(); + if (!s) + return { t: et, l: 0 }; + if (s == 1) { + var v = new u8(t[0].s + 1); + v[t[0].s] = 1; + return { t: v, l: 1 }; + } + t.sort(function (a, b) { return a.f - b.f; }); + // after i2 reaches last ind, will be stopped + // freq must be greater than largest possible number of symbols + t.push({ s: -1, f: 25001 }); + var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2; + t[0] = { s: -1, f: l.f + r.f, l: l, r: r }; + // efficient algorithm from UZIP.js + // i0 is lookbehind, i2 is lookahead - after processing two low-freq + // symbols that combined have high freq, will start processing i2 (high-freq, + // non-composite) symbols instead + // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/ + while (i1 != s - 1) { + l = t[t[i0].f < t[i2].f ? i0++ : i2++]; + r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++]; + t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r }; + } + var maxSym = t2[0].s; + for (var i = 1; i < s; ++i) { + if (t2[i].s > maxSym) + maxSym = t2[i].s; + } + // code lengths + var tr = new u16(maxSym + 1); + // max bits in tree + var mbt = ln(t[i1 - 1], tr, 0); + if (mbt > mb) { + // more algorithms from UZIP.js + // TODO: find out how this code works (debt) + // ind debt + var i = 0, dt = 0; + // left cost + var lft = mbt - mb, cst = 1 << lft; + t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; }); + for (; i < s; ++i) { + var i2_1 = t2[i].s; + if (tr[i2_1] > mb) { + dt += cst - (1 << (mbt - tr[i2_1])); + tr[i2_1] = mb; + } + else + break; + } + dt >>= lft; + while (dt > 0) { + var i2_2 = t2[i].s; + if (tr[i2_2] < mb) + dt -= 1 << (mb - tr[i2_2]++ - 1); + else + ++i; + } + for (; i >= 0 && dt; --i) { + var i2_3 = t2[i].s; + if (tr[i2_3] == mb) { + --tr[i2_3]; + ++dt; + } + } + mbt = mb; + } + return { t: new u8(tr), l: mbt }; +}; +// get the max length and assign length codes +var ln = function (n, l, d) { + return n.s == -1 + ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) + : (l[n.s] = d); +}; +// length codes generation +var lc = function (c) { + var s = c.length; + // Note that the semicolon was intentional + while (s && !c[--s]) + ; + var cl = new u16(++s); + // ind num streak + var cli = 0, cln = c[0], cls = 1; + var w = function (v) { cl[cli++] = v; }; + for (var i = 1; i <= s; ++i) { + if (c[i] == cln && i != s) + ++cls; + else { + if (!cln && cls > 2) { + for (; cls > 138; cls -= 138) + w(32754); + if (cls > 2) { + w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305); + cls = 0; + } + } + else if (cls > 3) { + w(cln), --cls; + for (; cls > 6; cls -= 6) + w(8304); + if (cls > 2) + w(((cls - 3) << 5) | 8208), cls = 0; + } + while (cls--) + w(cln); + cls = 1; + cln = c[i]; + } + } + return { c: cl.subarray(0, cli), n: s }; +}; +// calculate the length of output from tree, code lengths +var clen = function (cf, cl) { + var l = 0; + for (var i = 0; i < cl.length; ++i) + l += cf[i] * cl[i]; + return l; +}; +// writes a fixed block +// returns the new bit pos +var wfblk = function (out, pos, dat) { + // no need to write 00 as type: TypedArray defaults to 0 + var s = dat.length; + var o = shft(pos + 2); + out[o] = s & 255; + out[o + 1] = s >> 8; + out[o + 2] = out[o] ^ 255; + out[o + 3] = out[o + 1] ^ 255; + for (var i = 0; i < s; ++i) + out[o + i + 4] = dat[i]; + return (o + 4 + s) * 8; +}; +// writes a block +var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) { + wbits(out, p++, final); + ++lf[256]; + var _a = hTree(lf, 15), dlt = _a.t, mlb = _a.l; + var _b = hTree(df, 15), ddt = _b.t, mdb = _b.l; + var _c = lc(dlt), lclt = _c.c, nlc = _c.n; + var _d = lc(ddt), lcdt = _d.c, ndc = _d.n; + var lcfreq = new u16(19); + for (var i = 0; i < lclt.length; ++i) + ++lcfreq[lclt[i] & 31]; + for (var i = 0; i < lcdt.length; ++i) + ++lcfreq[lcdt[i] & 31]; + var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l; + var nlcc = 19; + for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc) + ; + var flen = (bl + 5) << 3; + var ftlen = clen(lf, flt) + clen(df, fdt) + eb; + var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]; + if (bs >= 0 && flen <= ftlen && flen <= dtlen) + return wfblk(out, p, dat.subarray(bs, bs + bl)); + var lm, ll, dm, dl; + wbits(out, p, 1 + (dtlen < ftlen)), p += 2; + if (dtlen < ftlen) { + lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt; + var llm = hMap(lct, mlcb, 0); + wbits(out, p, nlc - 257); + wbits(out, p + 5, ndc - 1); + wbits(out, p + 10, nlcc - 4); + p += 14; + for (var i = 0; i < nlcc; ++i) + wbits(out, p + 3 * i, lct[clim[i]]); + p += 3 * nlcc; + var lcts = [lclt, lcdt]; + for (var it = 0; it < 2; ++it) { + var clct = lcts[it]; + for (var i = 0; i < clct.length; ++i) { + var len = clct[i] & 31; + wbits(out, p, llm[len]), p += lct[len]; + if (len > 15) + wbits(out, p, (clct[i] >> 5) & 127), p += clct[i] >> 12; + } + } + } + else { + lm = flm, ll = flt, dm = fdm, dl = fdt; + } + for (var i = 0; i < li; ++i) { + var sym = syms[i]; + if (sym > 255) { + var len = (sym >> 18) & 31; + wbits16(out, p, lm[len + 257]), p += ll[len + 257]; + if (len > 7) + wbits(out, p, (sym >> 23) & 31), p += fleb[len]; + var dst = sym & 31; + wbits16(out, p, dm[dst]), p += dl[dst]; + if (dst > 3) + wbits16(out, p, (sym >> 5) & 8191), p += fdeb[dst]; + } + else { + wbits16(out, p, lm[sym]), p += ll[sym]; + } + } + wbits16(out, p, lm[256]); + return p + ll[256]; +}; +// deflate options (nice << 13) | chain +var deo = /*#__PURE__*/ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]); +// empty +var et = /*#__PURE__*/ new u8(0); +// compresses data into a raw DEFLATE buffer +var dflt = function (dat, lvl, plvl, pre, post, st) { + var s = st.z || dat.length; + var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post); + // writing to this writes to the output buffer + var w = o.subarray(pre, o.length - post); + var lst = st.l; + var pos = (st.r || 0) & 7; + if (lvl) { + if (pos) + w[0] = st.r >> 3; + var opt = deo[lvl - 1]; + var n = opt >> 13, c = opt & 8191; + var msk_1 = (1 << plvl) - 1; + // prev 2-byte val map curr 2-byte val map + var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1); + var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1; + var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; }; + // 24576 is an arbitrary number of maximum symbols per block + // 424 buffer for last block + var syms = new i32(25000); + // length/literal freq distance freq + var lf = new u16(288), df = new u16(32); + // l/lcnt exbits index l/lind waitdx blkpos + var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0; + for (; i + 2 < s; ++i) { + // hash value + var hv = hsh(i); + // index mod 32768 previous index mod + var imod = i & 32767, pimod = head[hv]; + prev[imod] = pimod; + head[hv] = imod; + // We always should modify head and prev, but only add symbols if + // this data is not yet processed ("wait" for wait index) + if (wi <= i) { + // bytes remaining + var rem = s - i; + if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) { + pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos); + li = lc_1 = eb = 0, bs = i; + for (var j = 0; j < 286; ++j) + lf[j] = 0; + for (var j = 0; j < 30; ++j) + df[j] = 0; + } + // len dist chain + var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767; + if (rem > 2 && hv == hsh(i - dif)) { + var maxn = Math.min(n, rem) - 1; + var maxd = Math.min(32767, i); + // max possible length + // not capped at dif because decompressors implement "rolling" index population + var ml = Math.min(258, rem); + while (dif <= maxd && --ch_1 && imod != pimod) { + if (dat[i + l] == dat[i + l - dif]) { + var nl = 0; + for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl) + ; + if (nl > l) { + l = nl, d = dif; + // break out early when we reach "nice" (we are satisfied enough) + if (nl > maxn) + break; + // now, find the rarest 2-byte sequence within this + // length of literals and search for that instead. + // Much faster than just using the start + var mmd = Math.min(dif, nl - 2); + var md = 0; + for (var j = 0; j < mmd; ++j) { + var ti = i - dif + j & 32767; + var pti = prev[ti]; + var cd = ti - pti & 32767; + if (cd > md) + md = cd, pimod = ti; + } + } + } + // check the previous match + imod = pimod, pimod = prev[imod]; + dif += imod - pimod & 32767; + } + } + // d will be nonzero only when a match was found + if (d) { + // store both dist and len data in one int32 + // Make sure this is recognized as a len/dist with 28th bit (2^28) + syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d]; + var lin = revfl[l] & 31, din = revfd[d] & 31; + eb += fleb[lin] + fdeb[din]; + ++lf[257 + lin]; + ++df[din]; + wi = i + l; + ++lc_1; + } + else { + syms[li++] = dat[i]; + ++lf[dat[i]]; + } + } + } + for (i = Math.max(i, wi); i < s; ++i) { + syms[li++] = dat[i]; + ++lf[dat[i]]; + } + pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos); + if (!lst) { + st.r = (pos & 7) | w[(pos / 8) | 0] << 3; + // shft(pos) now 1 less if pos & 7 != 0 + pos -= 7; + st.h = head, st.p = prev, st.i = i, st.w = wi; + } + } + else { + for (var i = st.w || 0; i < s + lst; i += 65535) { + // end + var e = i + 65535; + if (e >= s) { + // write final block + w[(pos / 8) | 0] = lst; + e = s; + } + pos = wfblk(w, pos + 1, dat.subarray(i, e)); + } + st.i = s; + } + return slc(o, 0, pre + shft(pos) + post); +}; +// CRC32 table +var crct = /*#__PURE__*/ (function () { + var t = new Int32Array(256); + for (var i = 0; i < 256; ++i) { + var c = i, k = 9; + while (--k) + c = ((c & 1) && -306674912) ^ (c >>> 1); + t[i] = c; + } + return t; +})(); +// CRC32 +var crc = function () { + var c = -1; + return { + p: function (d) { + // closures have awful performance + var cr = c; + for (var i = 0; i < d.length; ++i) + cr = crct[(cr & 255) ^ d[i]] ^ (cr >>> 8); + c = cr; + }, + d: function () { return ~c; } + }; +}; +// Adler32 +var adler = function () { + var a = 1, b = 0; + return { + p: function (d) { + // closures have awful performance + var n = a, m = b; + var l = d.length | 0; + for (var i = 0; i != l;) { + var e = Math.min(i + 2655, l); + for (; i < e; ++i) + m += n += d[i]; + n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16); + } + a = n, b = m; + }, + d: function () { + a %= 65521, b %= 65521; + return (a & 255) << 24 | (a & 0xFF00) << 8 | (b & 255) << 8 | (b >> 8); + } + }; +}; +; +// deflate with opts +var dopt = function (dat, opt, pre, post, st) { + if (!st) { + st = { l: 1 }; + if (opt.dictionary) { + var dict = opt.dictionary.subarray(-32768); + var newDat = new u8(dict.length + dat.length); + newDat.set(dict); + newDat.set(dat, dict.length); + dat = newDat; + st.w = dict.length; + } + } + return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? (st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20) : (12 + opt.mem), pre, post, st); +}; +// Walmart object spread +var mrg = function (a, b) { + var o = {}; + for (var k in a) + o[k] = a[k]; + for (var k in b) + o[k] = b[k]; + return o; +}; +// worker clone +// This is possibly the craziest part of the entire codebase, despite how simple it may seem. +// The only parameter to this function is a closure that returns an array of variables outside of the function scope. +// We're going to try to figure out the variable names used in the closure as strings because that is crucial for workerization. +// We will return an object mapping of true variable name to value (basically, the current scope as a JS object). +// The reason we can't just use the original variable names is minifiers mangling the toplevel scope. +// This took me three weeks to figure out how to do. +var wcln = function (fn, fnStr, td) { + var dt = fn(); + var st = fn.toString(); + var ks = st.slice(st.indexOf('[') + 1, st.lastIndexOf(']')).replace(/\s+/g, '').split(','); + for (var i = 0; i < dt.length; ++i) { + var v = dt[i], k = ks[i]; + if (typeof v == 'function') { + fnStr += ';' + k + '='; + var st_1 = v.toString(); + if (v.prototype) { + // for global objects + if (st_1.indexOf('[native code]') != -1) { + var spInd = st_1.indexOf(' ', 8) + 1; + fnStr += st_1.slice(spInd, st_1.indexOf('(', spInd)); + } + else { + fnStr += st_1; + for (var t in v.prototype) + fnStr += ';' + k + '.prototype.' + t + '=' + v.prototype[t].toString(); + } + } + else + fnStr += st_1; + } + else + td[k] = v; + } + return fnStr; +}; +var ch = []; +// clone bufs +var cbfs = function (v) { + var tl = []; + for (var k in v) { + if (v[k].buffer) { + tl.push((v[k] = new v[k].constructor(v[k])).buffer); + } + } + return tl; +}; +// use a worker to execute code +var wrkr = function (fns, init, id, cb) { + if (!ch[id]) { + var fnStr = '', td_1 = {}, m = fns.length - 1; + for (var i = 0; i < m; ++i) + fnStr = wcln(fns[i], fnStr, td_1); + ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 }; + } + var td = mrg({}, ch[id].e); + return wk(ch[id].c + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb); +}; +// base async inflate fn +var bInflt = function () { return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt]; }; +var bDflt = function () { return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; }; +// gzip extra +var gze = function () { return [gzh, gzhl, wbytes, crc, crct]; }; +// gunzip extra +var guze = function () { return [gzs, gzl]; }; +// zlib extra +var zle = function () { return [zlh, wbytes, adler]; }; +// unzlib extra +var zule = function () { return [zls]; }; +// post buf +var pbf = function (msg) { return postMessage(msg, [msg.buffer]); }; +// get opts +var gopt = function (o) { return o && { + out: o.size && new u8(o.size), + dictionary: o.dictionary +}; }; +// async helper +var cbify = function (dat, opts, fns, init, id, cb) { + var w = wrkr(fns, init, id, function (err, dat) { + w.terminate(); + cb(err, dat); + }); + w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []); + return function () { w.terminate(); }; +}; +// auto stream +var astrm = function (strm) { + strm.ondata = function (dat, final) { return postMessage([dat, final], [dat.buffer]); }; + return function (ev) { + if (ev.data[0]) { + strm.push(ev.data[0], ev.data[1]); + postMessage([ev.data[0].length]); + } + else + strm.flush(ev.data[1]); + }; +}; +// async stream attach +var astrmify = function (fns, strm, opts, init, id, flush, ext) { + var t; + var w = wrkr(fns, init, id, function (err, dat) { + if (err) + w.terminate(), strm.ondata.call(strm, err); + else if (!Array.isArray(dat)) + ext(dat); + else if (dat.length == 1) { + strm.queuedSize -= dat[0]; + if (strm.ondrain) + strm.ondrain(dat[0]); + } + else { + if (dat[1]) + w.terminate(); + strm.ondata.call(strm, err, dat[0], dat[1]); + } + }); + w.postMessage(opts); + strm.queuedSize = 0; + strm.push = function (d, f) { + if (!strm.ondata) + err(5); + if (t) + strm.ondata(err(4, 0, 1), null, !!f); + strm.queuedSize += d.length; + // can fail for cross-realm Uint8Array, but ok - only a small performance penalty + w.postMessage([d, t = f], d.buffer instanceof ArrayBuffer ? [d.buffer] : []); + }; + strm.terminate = function () { w.terminate(); }; + if (flush) { + strm.flush = function (sync) { w.postMessage([0, sync]); }; + } +}; +// read 2 bytes +var b2 = function (d, b) { return d[b] | (d[b + 1] << 8); }; +// read 4 bytes +var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; }; +// read 8 bytes +var b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); }; +// write bytes +var wbytes = function (d, b, v) { + for (; v; ++b) + d[b] = v, v >>>= 8; +}; +// gzip header +var gzh = function (c, o) { + var fn = o.filename; + c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3; // assume Unix + if (o.mtime != 0) + wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1000)); + if (fn) { + c[3] = 8; + for (var i = 0; i <= fn.length; ++i) + c[i + 10] = fn.charCodeAt(i); + } +}; +// gzip footer: -8 to -4 = CRC, -4 to -0 is length +// gzip start +var gzs = function (d) { + if (d[0] != 31 || d[1] != 139 || d[2] != 8) + err(6, 'invalid gzip data'); + var flg = d[3]; + var st = 10; + if (flg & 4) + st += (d[10] | d[11] << 8) + 2; + for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) + ; + return st + (flg & 2); +}; +// gzip length +var gzl = function (d) { + var l = d.length; + return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0; +}; +// gzip header length +var gzhl = function (o) { return 10 + (o.filename ? o.filename.length + 1 : 0); }; +// zlib header +var zlh = function (c, o) { + var lv = o.level, fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2; + c[0] = 120, c[1] = (fl << 6) | (o.dictionary && 32); + c[1] |= 31 - ((c[0] << 8) | c[1]) % 31; + if (o.dictionary) { + var h = adler(); + h.p(o.dictionary); + wbytes(c, 2, h.d()); + } +}; +// zlib start +var zls = function (d, dict) { + if ((d[0] & 15) != 8 || (d[0] >> 4) > 7 || ((d[0] << 8 | d[1]) % 31)) + err(6, 'invalid zlib data'); + if ((d[1] >> 5 & 1) == +!dict) + err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary'); + return (d[1] >> 3 & 4) + 2; +}; +function StrmOpt(opts, cb) { + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + return opts; +} +/** + * Streaming DEFLATE compression + */ +var Deflate = /*#__PURE__*/ (function () { + function Deflate(opts, cb) { + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + this.o = opts || {}; + this.s = { l: 0, i: 32768, w: 32768, z: 32768 }; + // Buffer length must always be 0 mod 32768 for index calculations to be correct when modifying head and prev + // 98304 = 32768 (lookback) + 65536 (common chunk size) + this.b = new u8(98304); + if (this.o.dictionary) { + var dict = this.o.dictionary.subarray(-32768); + this.b.set(dict, 32768 - dict.length); + this.s.i = 32768 - dict.length; + } + } + Deflate.prototype.p = function (c, f) { + this.ondata(dopt(c, this.o, 0, 0, this.s), f); + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Deflate.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (this.s.l) + err(4); + var endLen = chunk.length + this.s.z; + if (endLen > this.b.length) { + if (endLen > 2 * this.b.length - 32768) { + var newBuf = new u8(endLen & -32768); + newBuf.set(this.b.subarray(0, this.s.z)); + this.b = newBuf; + } + var split = this.b.length - this.s.z; + this.b.set(chunk.subarray(0, split), this.s.z); + this.s.z = this.b.length; + this.p(this.b, false); + this.b.set(this.b.subarray(-32768)); + this.b.set(chunk.subarray(split), 32768); + this.s.z = chunk.length - split + 32768; + this.s.i = 32766, this.s.w = 32768; + } + else { + this.b.set(chunk, this.s.z); + this.s.z += chunk.length; + } + this.s.l = final & 1; + if (this.s.z > this.s.w + 8191 || final) { + this.p(this.b, final || false); + this.s.w = this.s.i, this.s.i -= 2; + } + if (final) { + // cleanup unneeded buffers/state to reduce memory usage + this.s = this.o = {}; + this.b = et; + } + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + Deflate.prototype.flush = function (sync) { + if (!this.ondata) + err(5); + if (this.s.l) + err(4); + this.p(this.b, false); + this.s.w = this.s.i, this.s.i -= 2; + // could technically skip writing the type-0 block for (this.s.r & 7) == 0, + // but the deterministic trailer (00 00 FF FF) is useful in some situations + if (sync) { + var c = new u8(6); + c[0] = this.s.r >> 3; + // write empty, non-final type-0 block + var ep = wfblk(c, this.s.r, et); + this.s.r = 0; + this.ondata(c.subarray(0, ep >> 3), false); + } + }; + return Deflate; +}()); +export { Deflate }; +/** + * Asynchronous streaming DEFLATE compression + */ +var AsyncDeflate = /*#__PURE__*/ (function () { + function AsyncDeflate(opts, cb) { + astrmify([ + bDflt, + function () { return [astrm, Deflate]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Deflate(ev.data); + onmessage = astrm(strm); + }, 6, 1); + } + return AsyncDeflate; +}()); +export { AsyncDeflate }; +export function deflate(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + ], function (ev) { return pbf(deflateSync(ev.data[0], ev.data[1])); }, 0, cb); +} +/** + * Compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @returns The deflated version of the data + */ +export function deflateSync(data, opts) { + return dopt(data, opts || {}, 0, 0); +} +/** + * Streaming DEFLATE decompression + */ +var Inflate = /*#__PURE__*/ (function () { + function Inflate(opts, cb) { + // no StrmOpt here to avoid adding to workerizer + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768); + this.s = { i: 0, b: dict ? dict.length : 0 }; + this.o = new u8(32768); + this.p = new u8(0); + if (dict) + this.o.set(dict); + } + Inflate.prototype.e = function (c) { + if (!this.ondata) + err(5); + if (this.d) + err(4); + if (!this.p.length) + this.p = c; + else if (c.length) { + var n = new u8(this.p.length + c.length); + n.set(this.p), n.set(c, this.p.length), this.p = n; + } + }; + Inflate.prototype.c = function (final) { + this.s.i = +(this.d = final || false); + var bts = this.s.b; + var dt = inflt(this.p, this.s, this.o); + this.ondata(slc(dt, bts, this.s.b), this.d); + this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length; + this.p = slc(this.p, (this.s.p / 8) | 0), this.s.p &= 7; + }; + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the final chunk + */ + Inflate.prototype.push = function (chunk, final) { + this.e(chunk), this.c(final); + }; + return Inflate; +}()); +export { Inflate }; +/** + * Asynchronous streaming DEFLATE decompression + */ +var AsyncInflate = /*#__PURE__*/ (function () { + function AsyncInflate(opts, cb) { + astrmify([ + bInflt, + function () { return [astrm, Inflate]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Inflate(ev.data); + onmessage = astrm(strm); + }, 7, 0); + } + return AsyncInflate; +}()); +export { AsyncInflate }; +export function inflate(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt + ], function (ev) { return pbf(inflateSync(ev.data[0], gopt(ev.data[1]))); }, 1, cb); +} +export function inflateSync(data, opts) { + return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary); +} +// before you yell at me for not just using extends, my reason is that TS inheritance is hard to workerize. +/** + * Streaming GZIP compression + */ +var Gzip = /*#__PURE__*/ (function () { + function Gzip(opts, cb) { + this.c = crc(); + this.l = 0; + this.v = 1; + Deflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Gzip.prototype.push = function (chunk, final) { + this.c.p(chunk); + this.l += chunk.length; + Deflate.prototype.push.call(this, chunk, final); + }; + Gzip.prototype.p = function (c, f) { + var raw = dopt(c, this.o, this.v && gzhl(this.o), f && 8, this.s); + if (this.v) + gzh(raw, this.o), this.v = 0; + if (f) + wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l); + this.ondata(raw, f); + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + Gzip.prototype.flush = function (sync) { + Deflate.prototype.flush.call(this, sync); + }; + return Gzip; +}()); +export { Gzip }; +/** + * Asynchronous streaming GZIP compression + */ +var AsyncGzip = /*#__PURE__*/ (function () { + function AsyncGzip(opts, cb) { + astrmify([ + bDflt, + gze, + function () { return [astrm, Deflate, Gzip]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Gzip(ev.data); + onmessage = astrm(strm); + }, 8, 1); + } + return AsyncGzip; +}()); +export { AsyncGzip }; +export function gzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + gze, + function () { return [gzipSync]; } + ], function (ev) { return pbf(gzipSync(ev.data[0], ev.data[1])); }, 2, cb); +} +/** + * Compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @returns The gzipped version of the data + */ +export function gzipSync(data, opts) { + if (!opts) + opts = {}; + var c = crc(), l = data.length; + c.p(data); + var d = dopt(data, opts, gzhl(opts), 8), s = d.length; + return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d; +} +/** + * Streaming single or multi-member GZIP decompression + */ +var Gunzip = /*#__PURE__*/ (function () { + function Gunzip(opts, cb) { + this.v = 1; + this.r = 0; + Inflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Gunzip.prototype.push = function (chunk, final) { + Inflate.prototype.e.call(this, chunk); + this.r += chunk.length; + if (this.v) { + var p = this.p.subarray(this.v - 1); + var s = p.length > 3 ? gzs(p) : 4; + if (s > p.length) { + if (!final) + return; + } + else if (this.v > 1 && this.onmember) { + this.onmember(this.r - p.length); + } + this.p = p.subarray(s), this.v = 0; + } + // necessary to prevent TS from using the closure value + // This allows for workerization to function correctly + Inflate.prototype.c.call(this, 0); + // process concatenated GZIP + if (this.s.f && !this.s.l) { + this.v = shft(this.s.p) + 9; + this.s = { i: 0 }; + this.o = new u8(0); + this.push(new u8(0), final); + } + else if (final) { + Inflate.prototype.c.call(this, final); + } + }; + return Gunzip; +}()); +export { Gunzip }; +/** + * Asynchronous streaming single or multi-member GZIP decompression + */ +var AsyncGunzip = /*#__PURE__*/ (function () { + function AsyncGunzip(opts, cb) { + var _this = this; + astrmify([ + bInflt, + guze, + function () { return [astrm, Inflate, Gunzip]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Gunzip(ev.data); + strm.onmember = function (offset) { return postMessage(offset); }; + onmessage = astrm(strm); + }, 9, 0, function (offset) { return _this.onmember && _this.onmember(offset); }); + } + return AsyncGunzip; +}()); +export { AsyncGunzip }; +export function gunzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt, + guze, + function () { return [gunzipSync]; } + ], function (ev) { return pbf(gunzipSync(ev.data[0], ev.data[1])); }, 3, cb); +} +export function gunzipSync(data, opts) { + var st = gzs(data); + if (st + 8 > data.length) + err(6, 'invalid gzip data'); + return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary); +} +/** + * Streaming Zlib compression + */ +var Zlib = /*#__PURE__*/ (function () { + function Zlib(opts, cb) { + this.c = adler(); + this.v = 1; + Deflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be zlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Zlib.prototype.push = function (chunk, final) { + this.c.p(chunk); + Deflate.prototype.push.call(this, chunk, final); + }; + Zlib.prototype.p = function (c, f) { + var raw = dopt(c, this.o, this.v && (this.o.dictionary ? 6 : 2), f && 4, this.s); + if (this.v) + zlh(raw, this.o), this.v = 0; + if (f) + wbytes(raw, raw.length - 4, this.c.d()); + this.ondata(raw, f); + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + Zlib.prototype.flush = function (sync) { + Deflate.prototype.flush.call(this, sync); + }; + return Zlib; +}()); +export { Zlib }; +/** + * Asynchronous streaming Zlib compression + */ +var AsyncZlib = /*#__PURE__*/ (function () { + function AsyncZlib(opts, cb) { + astrmify([ + bDflt, + zle, + function () { return [astrm, Deflate, Zlib]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Zlib(ev.data); + onmessage = astrm(strm); + }, 10, 1); + } + return AsyncZlib; +}()); +export { AsyncZlib }; +export function zlib(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + zle, + function () { return [zlibSync]; } + ], function (ev) { return pbf(zlibSync(ev.data[0], ev.data[1])); }, 4, cb); +} +/** + * Compress data with Zlib + * @param data The data to compress + * @param opts The compression options + * @returns The zlib-compressed version of the data + */ +export function zlibSync(data, opts) { + if (!opts) + opts = {}; + var a = adler(); + a.p(data); + var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4); + return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d; +} +/** + * Streaming Zlib decompression + */ +var Unzlib = /*#__PURE__*/ (function () { + function Unzlib(opts, cb) { + Inflate.call(this, opts, cb); + this.v = opts && opts.dictionary ? 2 : 1; + } + /** + * Pushes a chunk to be unzlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Unzlib.prototype.push = function (chunk, final) { + Inflate.prototype.e.call(this, chunk); + if (this.v) { + if (this.p.length < 6 && !final) + return; + this.p = this.p.subarray(zls(this.p, this.v - 1)), this.v = 0; + } + if (final) { + if (this.p.length < 4) + err(6, 'invalid zlib data'); + this.p = this.p.subarray(0, -4); + } + // necessary to prevent TS from using the closure value + // This allows for workerization to function correctly + Inflate.prototype.c.call(this, final); + }; + return Unzlib; +}()); +export { Unzlib }; +/** + * Asynchronous streaming Zlib decompression + */ +var AsyncUnzlib = /*#__PURE__*/ (function () { + function AsyncUnzlib(opts, cb) { + astrmify([ + bInflt, + zule, + function () { return [astrm, Inflate, Unzlib]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Unzlib(ev.data); + onmessage = astrm(strm); + }, 11, 0); + } + return AsyncUnzlib; +}()); +export { AsyncUnzlib }; +export function unzlib(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt, + zule, + function () { return [unzlibSync]; } + ], function (ev) { return pbf(unzlibSync(ev.data[0], gopt(ev.data[1]))); }, 5, cb); +} +export function unzlibSync(data, opts) { + return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary); +} +// Default algorithm for compression (used because having a known output size allows faster decompression) +export { gzip as compress, AsyncGzip as AsyncCompress }; +export { gzipSync as compressSync, Gzip as Compress }; +/** + * Streaming GZIP, Zlib, or raw DEFLATE decompression + */ +var Decompress = /*#__PURE__*/ (function () { + function Decompress(opts, cb) { + this.o = StrmOpt.call(this, opts, cb) || {}; + this.G = Gunzip; + this.I = Inflate; + this.Z = Unzlib; + } + // init substream + // overriden by AsyncDecompress + Decompress.prototype.i = function () { + var _this = this; + this.s.ondata = function (dat, final) { + _this.ondata(dat, final); + }; + }; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Decompress.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (!this.s) { + if (this.p && this.p.length) { + var n = new u8(this.p.length + chunk.length); + n.set(this.p), n.set(chunk, this.p.length); + } + else + this.p = chunk; + if (this.p.length > 2) { + this.s = (this.p[0] == 31 && this.p[1] == 139 && this.p[2] == 8) + ? new this.G(this.o) + : ((this.p[0] & 15) != 8 || (this.p[0] >> 4) > 7 || ((this.p[0] << 8 | this.p[1]) % 31)) + ? new this.I(this.o) + : new this.Z(this.o); + this.i(); + this.s.push(this.p, final); + this.p = null; + } + } + else + this.s.push(chunk, final); + }; + return Decompress; +}()); +export { Decompress }; +/** + * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression + */ +var AsyncDecompress = /*#__PURE__*/ (function () { + function AsyncDecompress(opts, cb) { + Decompress.call(this, opts, cb); + this.queuedSize = 0; + this.G = AsyncGunzip; + this.I = AsyncInflate; + this.Z = AsyncUnzlib; + } + AsyncDecompress.prototype.i = function () { + var _this = this; + this.s.ondata = function (err, dat, final) { + _this.ondata(err, dat, final); + }; + this.s.ondrain = function (size) { + _this.queuedSize -= size; + if (_this.ondrain) + _this.ondrain(size); + }; + }; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + AsyncDecompress.prototype.push = function (chunk, final) { + this.queuedSize += chunk.length; + Decompress.prototype.push.call(this, chunk, final); + }; + return AsyncDecompress; +}()); +export { AsyncDecompress }; +export function decompress(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return (data[0] == 31 && data[1] == 139 && data[2] == 8) + ? gunzip(data, opts, cb) + : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31)) + ? inflate(data, opts, cb) + : unzlib(data, opts, cb); +} +/** + * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export function decompressSync(data, opts) { + return (data[0] == 31 && data[1] == 139 && data[2] == 8) + ? gunzipSync(data, opts) + : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31)) + ? inflateSync(data, opts) + : unzlibSync(data, opts); +} +// flatten a directory structure +var fltn = function (d, p, t, o) { + for (var k in d) { + var val = d[k], n = p + k, op = o; + if (Array.isArray(val)) + op = mrg(o, val[1]), val = val[0]; + if (ArrayBuffer.isView(val)) + t[n] = [val, op]; + else { + t[n += '/'] = [new u8(0), op]; + fltn(val, n, t, o); + } + } +}; +// text encoder +var te = typeof TextEncoder != 'undefined' && /*#__PURE__*/ new TextEncoder(); +// text decoder +var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder(); +// text decoder stream +var tds = 0; +try { + td.decode(et, { stream: true }); + tds = 1; +} +catch (e) { } +// decode UTF8 +var dutf8 = function (d) { + for (var r = '', i = 0;;) { + var c = d[i++]; + var eb = (c > 127) + (c > 223) + (c > 239); + if (i + eb > d.length) + return { s: r, r: slc(d, i - 1) }; + if (!eb) + r += String.fromCharCode(c); + else if (eb == 3) { + c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536, + r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023)); + } + else if (eb & 1) + r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63)); + else + r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)); + } +}; +/** + * Streaming UTF-8 decoding + */ +var DecodeUTF8 = /*#__PURE__*/ (function () { + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is decoded + */ + function DecodeUTF8(cb) { + this.ondata = cb; + if (tds) + this.t = new TextDecoder(); + else + this.p = et; + } + /** + * Pushes a chunk to be decoded from UTF-8 binary + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + DecodeUTF8.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + final = !!final; + if (this.t) { + this.ondata(this.t.decode(chunk, { stream: true }), final); + if (final) { + if (this.t.decode().length) + err(8); + this.t = null; + } + return; + } + if (!this.p) + err(4); + var dat = new u8(this.p.length + chunk.length); + dat.set(this.p); + dat.set(chunk, this.p.length); + var _a = dutf8(dat), s = _a.s, r = _a.r; + if (final) { + if (r.length) + err(8); + this.p = null; + } + else + this.p = r; + this.ondata(s, final); + }; + return DecodeUTF8; +}()); +export { DecodeUTF8 }; +/** + * Streaming UTF-8 encoding + */ +var EncodeUTF8 = /*#__PURE__*/ (function () { + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is encoded + */ + function EncodeUTF8(cb) { + this.ondata = cb; + } + /** + * Pushes a chunk to be encoded to UTF-8 + * @param chunk The string data to push + * @param final Whether this is the last chunk + */ + EncodeUTF8.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (this.d) + err(4); + this.ondata(strToU8(chunk), this.d = final || false); + }; + return EncodeUTF8; +}()); +export { EncodeUTF8 }; +/** + * Converts a string into a Uint8Array for use with compression/decompression methods + * @param str The string to encode + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless decoding a binary string. + * @returns The string encoded in UTF-8/Latin-1 binary + */ +export function strToU8(str, latin1) { + if (latin1) { + var ar_1 = new u8(str.length); + for (var i = 0; i < str.length; ++i) + ar_1[i] = str.charCodeAt(i); + return ar_1; + } + if (te) + return te.encode(str); + var l = str.length; + var ar = new u8(str.length + (str.length >> 1)); + var ai = 0; + var w = function (v) { ar[ai++] = v; }; + for (var i = 0; i < l; ++i) { + if (ai + 5 > ar.length) { + var n = new u8(ai + 8 + ((l - i) << 1)); + n.set(ar); + ar = n; + } + var c = str.charCodeAt(i); + if (c < 128 || latin1) + w(c); + else if (c < 2048) + w(192 | (c >> 6)), w(128 | (c & 63)); + else if (c > 55295 && c < 57344) + c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023), + w(240 | (c >> 18)), w(128 | ((c >> 12) & 63)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63)); + else + w(224 | (c >> 12)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63)); + } + return slc(ar, 0, ai); +} +/** + * Converts a Uint8Array to a string + * @param dat The data to decode to string + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless encoding to binary string. + * @returns The original UTF-8/Latin-1 string + */ +export function strFromU8(dat, latin1) { + if (latin1) { + var r = ''; + for (var i = 0; i < dat.length; i += 16384) + r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384)); + return r; + } + else if (td) { + return td.decode(dat); + } + else { + var _a = dutf8(dat), s = _a.s, r = _a.r; + if (r.length) + err(8); + return s; + } +} +; +// deflate bit flag +var dbf = function (l) { return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0; }; +// skip local zip header +var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); }; +// read zip header +var zh = function (d, b, z) { + var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl; + var _a = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a[0], su = _a[1], off = _a[2]; + return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off]; +}; +// read zip64 header sizes +var z64hs = function (d, b, l, z, sc, su, off) { + var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l; + var nf = nsc + nsu + noff; + if (z && nf) { + for (; b + 4 < e; b += 4 + b2(d, b + 2)) { + if (b2(d, b) == 1) { + return [ + nsc ? b8(d, b + 4 + 8 * nsu) : sc, + nsu ? b8(d, b + 4) : su, + noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off, + 1 + ]; + } + } + // z == 2 for unknown whether or not zip64 + if (z < 2) + err(13); + } + return [sc, su, off, 0]; +}; +// extra field length +var exfl = function (ex) { + var le = 0; + if (ex) { + for (var k in ex) { + var l = ex[k].length; + if (l > 65535) + err(9); + le += l + 4; + } + } + return le; +}; +// write zip header +var wzh = function (d, b, f, fn, u, c, ce, co) { + var fl = fn.length, ex = f.extra, col = co && co.length; + var exl = exfl(ex); + wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4; + if (ce != null) + d[b++] = 20, d[b++] = f.os; + d[b] = 20, b += 2; // spec compliance? what's that? + d[b++] = (f.flag << 1) | (c < 0 && 8), d[b++] = u && 8; + d[b++] = f.compression & 255, d[b++] = f.compression >> 8; + var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980; + if (y < 0 || y > 119) + err(10); + wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >> 1)), b += 4; + if (c != -1) { + wbytes(d, b, f.crc); + wbytes(d, b + 4, c < 0 ? -c - 2 : c); + wbytes(d, b + 8, f.size); + } + wbytes(d, b + 12, fl); + wbytes(d, b + 14, exl), b += 16; + if (ce != null) { + wbytes(d, b, col); + wbytes(d, b + 6, f.attrs); + wbytes(d, b + 10, ce), b += 14; + } + d.set(fn, b); + b += fl; + if (exl) { + for (var k in ex) { + var exf = ex[k], l = exf.length; + wbytes(d, b, +k); + wbytes(d, b + 2, l); + d.set(exf, b + 4), b += 4 + l; + } + } + if (col) + d.set(co, b), b += col; + return b; +}; +// write zip footer (end of central directory) +var wzf = function (o, b, c, d, e) { + wbytes(o, b, 0x6054B50); // skip disk + wbytes(o, b + 8, c); + wbytes(o, b + 10, c); + wbytes(o, b + 12, d); + wbytes(o, b + 16, e); +}; +/** + * A pass-through stream to keep data uncompressed in a ZIP archive. + */ +var ZipPassThrough = /*#__PURE__*/ (function () { + /** + * Creates a pass-through stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + */ + function ZipPassThrough(filename) { + this.filename = filename; + this.c = crc(); + this.size = 0; + this.compression = 0; + } + /** + * Processes a chunk and pushes to the output stream. You can override this + * method in a subclass for custom behavior, but by default this passes + * the data through. You must call this.ondata(err, chunk, final) at some + * point in this method. + * @param chunk The chunk to process + * @param final Whether this is the last chunk + */ + ZipPassThrough.prototype.process = function (chunk, final) { + this.ondata(null, chunk, final); + }; + /** + * Pushes a chunk to be added. If you are subclassing this with a custom + * compression algorithm, note that you must push data from the source + * file only, pre-compression. + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + ZipPassThrough.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + this.c.p(chunk); + this.size += chunk.length; + if (final) + this.crc = this.c.d(); + // we shouldn't really do this cast, but properly handling ArrayBufferLike + // makes the API unergonomic with Buffer + this.process(chunk, final || false); + }; + return ZipPassThrough; +}()); +export { ZipPassThrough }; +// I don't extend because TypeScript extension adds 1kB of runtime bloat +/** + * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate + * for better performance + */ +var ZipDeflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + function ZipDeflate(filename, opts) { + var _this = this; + if (!opts) + opts = {}; + ZipPassThrough.call(this, filename); + this.d = new Deflate(opts, function (dat, final) { + _this.ondata(null, dat, final); + }); + this.compression = 8; + this.flag = dbf(opts.level); + } + ZipDeflate.prototype.process = function (chunk, final) { + try { + this.d.push(chunk, final); + } + catch (e) { + this.ondata(e, null, final); + } + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + ZipDeflate.prototype.push = function (chunk, final) { + ZipPassThrough.prototype.push.call(this, chunk, final); + }; + return ZipDeflate; +}()); +export { ZipDeflate }; +/** + * Asynchronous streaming DEFLATE compression for ZIP archives + */ +var AsyncZipDeflate = /*#__PURE__*/ (function () { + /** + * Creates an asynchronous DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + function AsyncZipDeflate(filename, opts) { + var _this = this; + if (!opts) + opts = {}; + ZipPassThrough.call(this, filename); + this.d = new AsyncDeflate(opts, function (err, dat, final) { + _this.ondata(err, dat, final); + }); + this.compression = 8; + this.flag = dbf(opts.level); + this.terminate = this.d.terminate; + } + AsyncZipDeflate.prototype.process = function (chunk, final) { + this.d.push(chunk, final); + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + AsyncZipDeflate.prototype.push = function (chunk, final) { + ZipPassThrough.prototype.push.call(this, chunk, final); + }; + return AsyncZipDeflate; +}()); +export { AsyncZipDeflate }; +// TODO: Better tree shaking +/** + * A zippable archive to which files can incrementally be added + */ +var Zip = /*#__PURE__*/ (function () { + /** + * Creates an empty ZIP archive to which files can be added + * @param cb The callback to call whenever data for the generated ZIP archive + * is available + */ + function Zip(cb) { + this.ondata = cb; + this.u = []; + this.d = 1; + } + /** + * Adds a file to the ZIP archive + * @param file The file stream to add + */ + Zip.prototype.add = function (file) { + var _this = this; + if (!this.ondata) + err(5); + // finishing or finished + if (this.d & 2) + this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, false); + else { + var f = strToU8(file.filename), fl_1 = f.length; + var com = file.comment, o = com && strToU8(com); + var u = fl_1 != file.filename.length || (o && (com.length != o.length)); + var hl_1 = fl_1 + exfl(file.extra) + 30; + if (fl_1 > 65535) + this.ondata(err(11, 0, 1), null, false); + var header = new u8(hl_1); + wzh(header, 0, file, f, u, -1); + var chks_1 = [header]; + var pAll_1 = function () { + for (var _i = 0, chks_2 = chks_1; _i < chks_2.length; _i++) { + var chk = chks_2[_i]; + _this.ondata(null, chk, false); + } + chks_1 = []; + }; + var tr_1 = this.d; + this.d = 0; + var ind_1 = this.u.length; + var uf_1 = mrg(file, { + f: f, + u: u, + o: o, + t: function () { + if (file.terminate) + file.terminate(); + }, + r: function () { + pAll_1(); + if (tr_1) { + var nxt = _this.u[ind_1 + 1]; + if (nxt) + nxt.r(); + else + _this.d = 1; + } + tr_1 = 1; + } + }); + var cl_1 = 0; + file.ondata = function (err, dat, final) { + if (err) { + _this.ondata(err, dat, final); + _this.terminate(); + } + else { + cl_1 += dat.length; + chks_1.push(dat); + if (final) { + var dd = new u8(16); + wbytes(dd, 0, 0x8074B50); + wbytes(dd, 4, file.crc); + wbytes(dd, 8, cl_1); + wbytes(dd, 12, file.size); + chks_1.push(dd); + uf_1.c = cl_1, uf_1.b = hl_1 + cl_1 + 16, uf_1.crc = file.crc, uf_1.size = file.size; + if (tr_1) + uf_1.r(); + tr_1 = 1; + } + else if (tr_1) + pAll_1(); + } + }; + this.u.push(uf_1); + } + }; + /** + * Ends the process of adding files and prepares to emit the final chunks. + * This *must* be called after adding all desired files for the resulting + * ZIP file to work properly. + */ + Zip.prototype.end = function () { + var _this = this; + if (this.d & 2) { + this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, true); + return; + } + if (this.d) + this.e(); + else + this.u.push({ + r: function () { + if (!(_this.d & 1)) + return; + _this.u.splice(-1, 1); + _this.e(); + }, + t: function () { } + }); + this.d = 3; + }; + Zip.prototype.e = function () { + var bt = 0, l = 0, tl = 0; + for (var _i = 0, _a = this.u; _i < _a.length; _i++) { + var f = _a[_i]; + tl += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0); + } + var out = new u8(tl + 22); + for (var _b = 0, _c = this.u; _b < _c.length; _b++) { + var f = _c[_b]; + wzh(out, bt, f, f.f, f.u, -f.c - 2, l, f.o); + bt += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0), l += f.b; + } + wzf(out, bt, this.u.length, tl, l); + this.ondata(null, out, true); + this.d = 2; + }; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to add() will fail. + */ + Zip.prototype.terminate = function () { + for (var _i = 0, _a = this.u; _i < _a.length; _i++) { + var f = _a[_i]; + f.t(); + } + this.d = 2; + }; + return Zip; +}()); +export { Zip }; +export function zip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + var r = {}; + fltn(data, '', r, opts); + var k = Object.keys(r); + var lft = k.length, o = 0, tot = 0; + var slft = lft, files = new Array(lft); + var term = []; + var tAll = function () { + for (var i = 0; i < term.length; ++i) + term[i](); + }; + var cbd = function (a, b) { + mt(function () { cb(a, b); }); + }; + mt(function () { cbd = cb; }); + var cbf = function () { + var out = new u8(tot + 22), oe = o, cdl = tot - o; + tot = 0; + for (var i = 0; i < slft; ++i) { + var f = files[i]; + try { + var l = f.c.length; + wzh(out, tot, f, f.f, f.u, l); + var badd = 30 + f.f.length + exfl(f.extra); + var loc = tot + badd; + out.set(f.c, loc); + wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l; + } + catch (e) { + return cbd(e, null); + } + } + wzf(out, o, files.length, cdl, oe); + cbd(null, out); + }; + if (!lft) + cbf(); + var _loop_1 = function (i) { + var fn = k[i]; + var _a = r[fn], file = _a[0], p = _a[1]; + var c = crc(), size = file.length; + c.p(file); + var f = strToU8(fn), s = f.length; + var com = p.comment, m = com && strToU8(com), ms = m && m.length; + var exl = exfl(p.extra); + var compression = p.level == 0 ? 0 : 8; + var cbl = function (e, d) { + if (e) { + tAll(); + cbd(e, null); + } + else { + var l = d.length; + files[i] = mrg(p, { + size: size, + crc: c.d(), + c: d, + f: f, + m: m, + u: s != fn.length || (m && (com.length != ms)), + compression: compression + }); + o += 30 + s + exl + l; + tot += 76 + 2 * (s + exl) + (ms || 0) + l; + if (!--lft) + cbf(); + } + }; + if (s > 65535) + cbl(err(11, 0, 1), null); + if (!compression) + cbl(null, file); + else if (size < 160000) { + try { + cbl(null, deflateSync(file, p)); + } + catch (e) { + cbl(e, null); + } + } + else + term.push(deflate(file, p, cbl)); + }; + // Cannot use lft because it can decrease + for (var i = 0; i < slft; ++i) { + _loop_1(i); + } + return tAll; +} +/** + * Synchronously creates a ZIP file. Prefer using `zip` for better performance + * with more than one file. + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @returns The generated ZIP archive + */ +export function zipSync(data, opts) { + if (!opts) + opts = {}; + var r = {}; + var files = []; + fltn(data, '', r, opts); + var o = 0; + var tot = 0; + for (var fn in r) { + var _a = r[fn], file = _a[0], p = _a[1]; + var compression = p.level == 0 ? 0 : 8; + var f = strToU8(fn), s = f.length; + var com = p.comment, m = com && strToU8(com), ms = m && m.length; + var exl = exfl(p.extra); + if (s > 65535) + err(11); + var d = compression ? deflateSync(file, p) : file, l = d.length; + var c = crc(); + c.p(file); + files.push(mrg(p, { + size: file.length, + crc: c.d(), + c: d, + f: f, + m: m, + u: s != fn.length || (m && (com.length != ms)), + o: o, + compression: compression + })); + o += 30 + s + exl + l; + tot += 76 + 2 * (s + exl) + (ms || 0) + l; + } + var out = new u8(tot + 22), oe = o, cdl = tot - o; + for (var i = 0; i < files.length; ++i) { + var f = files[i]; + wzh(out, f.o, f, f.f, f.u, f.c.length); + var badd = 30 + f.f.length + exfl(f.extra); + out.set(f.c, f.o + badd); + wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0); + } + wzf(out, o, files.length, cdl, oe); + return out; +} +/** + * Streaming pass-through decompression for ZIP archives + */ +var UnzipPassThrough = /*#__PURE__*/ (function () { + function UnzipPassThrough() { + } + UnzipPassThrough.prototype.push = function (chunk, final) { + // same as ZipPassThrough: cast to retain Buffer ergonomics + this.ondata(null, chunk, final); + }; + UnzipPassThrough.compression = 0; + return UnzipPassThrough; +}()); +export { UnzipPassThrough }; +/** + * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for + * better performance. + */ +var UnzipInflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + function UnzipInflate() { + var _this = this; + this.i = new Inflate(function (dat, final) { + _this.ondata(null, dat, final); + }); + } + UnzipInflate.prototype.push = function (chunk, final) { + try { + this.i.push(chunk, final); + } + catch (e) { + this.ondata(e, null, final); + } + }; + UnzipInflate.compression = 8; + return UnzipInflate; +}()); +export { UnzipInflate }; +/** + * Asynchronous streaming DEFLATE decompression for ZIP archives + */ +var AsyncUnzipInflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + function AsyncUnzipInflate(_, sz) { + var _this = this; + if (sz < 320000) { + this.i = new Inflate(function (dat, final) { + _this.ondata(null, dat, final); + }); + } + else { + this.i = new AsyncInflate(function (err, dat, final) { + _this.ondata(err, dat, final); + }); + this.terminate = this.i.terminate; + } + } + AsyncUnzipInflate.prototype.push = function (chunk, final) { + if (this.i.terminate) + chunk = slc(chunk, 0); + this.i.push(chunk, final); + }; + AsyncUnzipInflate.compression = 8; + return AsyncUnzipInflate; +}()); +export { AsyncUnzipInflate }; +/** + * A ZIP archive decompression stream that emits files as they are discovered + */ +var Unzip = /*#__PURE__*/ (function () { + /** + * Creates a ZIP decompression stream + * @param cb The callback to call whenever a file in the ZIP archive is found + */ + function Unzip(cb) { + this.onfile = cb; + this.k = []; + this.o = { + 0: UnzipPassThrough + }; + this.p = et; + } + /** + * Pushes a chunk to be unzipped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Unzip.prototype.push = function (chunk, final) { + var _this = this; + if (!this.onfile) + err(5); + if (!this.p) + err(4); + if (this.c > 0) { + var len = Math.min(this.c, chunk.length); + var toAdd = chunk.subarray(0, len); + this.c -= len; + if (this.d) + this.d.push(toAdd, !this.c); + else + this.k[0].push(toAdd); + chunk = chunk.subarray(len); + if (chunk.length) + return this.push(chunk, final); + } + else { + var f = 0, i = 0, is = void 0, buf = void 0; + if (!this.p.length) + buf = chunk; + else if (!chunk.length) + buf = this.p; + else { + buf = new u8(this.p.length + chunk.length); + buf.set(this.p), buf.set(chunk, this.p.length); + } + var l = buf.length, oc = this.c, add = oc && this.d; + var _loop_2 = function () { + var sig = b4(buf, i); + if (sig == 0x4034B50) { + f = 1, is = i; + this_1.d = null; + this_1.c = 0; + var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28); + if (l > i + 30 + fnl + es) { + var chks_3 = []; + this_1.k.unshift(chks_3); + f = 2; + var lsc = b4(buf, i + 18), lsu = b4(buf, i + 22); + var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u); + var _a = z64hs(buf, i, es, 2, lsc, lsu, 0), sc_1 = _a[0], su_1 = _a[1], z64 = _a[3]; + if (dd) + sc_1 = -1 - z64; + i += es; + this_1.c = sc_1; + var d_1; + var file_1 = { + name: fn_1, + compression: cmp_1, + start: function () { + if (!file_1.ondata) + err(5); + if (!sc_1) + file_1.ondata(null, et, true); + else { + var ctr = _this.o[cmp_1]; + if (!ctr) + file_1.ondata(err(14, 'unknown compression type ' + cmp_1, 1), null, false); + d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1); + d_1.ondata = function (err, dat, final) { file_1.ondata(err, dat, final); }; + for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) { + var dat = chks_4[_i]; + d_1.push(dat, false); + } + if (_this.k[0] == chks_3 && _this.c) + _this.d = d_1; + else + d_1.push(et, true); + } + }, + terminate: function () { + if (d_1 && d_1.terminate) + d_1.terminate(); + } + }; + if (sc_1 >= 0) + file_1.size = sc_1, file_1.originalSize = su_1; + this_1.onfile(file_1); + } + return "break"; + } + else if (oc) { + if (sig == 0x8074B50) { + is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0; + return "break"; + } + else if (sig == 0x2014B50) { + is = i -= 4, f = 3, this_1.c = 0; + return "break"; + } + } + }; + var this_1 = this; + for (; i < l - 4; ++i) { + var state_1 = _loop_2(); + if (state_1 === "break") + break; + } + this.p = et; + if (oc < 0) { + var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 0x8074B50 && 4)) : buf.subarray(0, i); + if (add) + add.push(dat, !!f); + else + this.k[+(f == 2)].push(dat); + } + if (f & 2) + return this.push(buf.subarray(i), final); + this.p = buf.subarray(i); + } + if (final) { + if (this.c) + err(13); + this.p = null; + } + }; + /** + * Registers a decoder with the stream, allowing for files compressed with + * the compression type provided to be expanded correctly + * @param decoder The decoder constructor + */ + Unzip.prototype.register = function (decoder) { + this.o[decoder.compression] = decoder; + }; + return Unzip; +}()); +export { Unzip }; +var mt = typeof queueMicrotask == 'function' ? queueMicrotask : typeof setTimeout == 'function' ? setTimeout : function (fn) { fn(); }; +export function unzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + var term = []; + var tAll = function () { + for (var i = 0; i < term.length; ++i) + term[i](); + }; + var files = {}; + var cbd = function (a, b) { + mt(function () { cb(a, b); }); + }; + mt(function () { cbd = cb; }); + var e = data.length - 22; + for (; b4(data, e) != 0x6054B50; --e) { + if (!e || data.length - e > 65558) { + cbd(err(13, 0, 1), null); + return tAll; + } + } + ; + var lft = b2(data, e + 8); + if (lft) { + var c = lft; + var o = b4(data, e + 16); + var z = b4(data, e - 20) == 0x7064B50; + if (z) { + var ze = b4(data, e - 12); + z = b4(data, ze) == 0x6064B50; + if (z) { + c = lft = b4(data, ze + 32); + o = b4(data, ze + 48); + } + } + var fltr = opts && opts.filter; + var _loop_3 = function (i) { + var _a = zh(data, o, z), c_1 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off); + o = no; + var cbl = function (e, d) { + if (e) { + tAll(); + cbd(e, null); + } + else { + if (d) + files[fn] = d; + if (!--lft) + cbd(null, files); + } + }; + if (!fltr || fltr({ + name: fn, + size: sc, + originalSize: su, + compression: c_1 + })) { + if (!c_1) + cbl(null, slc(data, b, b + sc)); + else if (c_1 == 8) { + var infl = data.subarray(b, b + sc); + // Synchronously decompress under 512KB, or barely-compressed data + if (su < 524288 || sc > 0.8 * su) { + try { + cbl(null, inflateSync(infl, { out: new u8(su) })); + } + catch (e) { + cbl(e, null); + } + } + else + term.push(inflate(infl, { size: su }, cbl)); + } + else + cbl(err(14, 'unknown compression type ' + c_1, 1), null); + } + else + cbl(null, null); + }; + for (var i = 0; i < c; ++i) { + _loop_3(i); + } + } + else + cbd(null, {}); + return tAll; +} +/** + * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better + * performance with more than one file. + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @returns The decompressed files + */ +export function unzipSync(data, opts) { + var files = {}; + var e = data.length - 22; + for (; b4(data, e) != 0x6054B50; --e) { + if (!e || data.length - e > 65558) + err(13); + } + ; + var c = b2(data, e + 8); + if (!c) + return {}; + var o = b4(data, e + 16); + var z = b4(data, e - 20) == 0x7064B50; + if (z) { + var ze = b4(data, e - 12); + z = b4(data, ze) == 0x6064B50; + if (z) { + c = b4(data, ze + 32); + o = b4(data, ze + 48); + } + } + var fltr = opts && opts.filter; + for (var i = 0; i < c; ++i) { + var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off); + o = no; + if (!fltr || fltr({ + name: fn, + size: sc, + originalSize: su, + compression: c_2 + })) { + if (!c_2) + files[fn] = slc(data, b, b + sc); + else if (c_2 == 8) + files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) }); + else + err(14, 'unknown compression type ' + c_2); + } + } + return files; +} diff --git a/tools/ui/node_modules/fflate/lib/browser.cjs b/tools/ui/node_modules/fflate/lib/browser.cjs new file mode 100644 index 0000000000000000000000000000000000000000..d3427caca233f968e8b3dc9c1a2d96e81abe42d3 --- /dev/null +++ b/tools/ui/node_modules/fflate/lib/browser.cjs @@ -0,0 +1,2717 @@ +"use strict"; +// DEFLATE is a complex format; to read this code, you should probably check the RFC first: +// https://tools.ietf.org/html/rfc1951 +// You may also wish to take a look at the guide I made about this program: +// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad +exports.deflate = deflate; +exports.deflateSync = deflateSync; +exports.inflate = inflate; +exports.inflateSync = inflateSync; +exports.gzip = gzip; +exports.compress = gzip; +exports.gzipSync = gzipSync; +exports.compressSync = gzipSync; +exports.gunzip = gunzip; +exports.gunzipSync = gunzipSync; +exports.zlib = zlib; +exports.zlibSync = zlibSync; +exports.unzlib = unzlib; +exports.unzlibSync = unzlibSync; +exports.gzip = gzip; +exports.compress = gzip; +exports.decompress = decompress; +exports.decompressSync = decompressSync; +exports.strToU8 = strToU8; +exports.strFromU8 = strFromU8; +exports.zip = zip; +exports.zipSync = zipSync; +exports.unzip = unzip; +exports.unzipSync = unzipSync; +// Some of the following code is similar to that of UZIP.js: +// https://github.com/photopea/UZIP.js +// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size. +// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint +// is better for memory in most engines (I *think*). +var ch2 = {}; +var node_worker_1 = {}; +node_worker_1["default"] = (function (c, id, msg, transfer, cb) { + var w = new Worker(ch2[id] || (ch2[id] = URL.createObjectURL(new Blob([ + c + ';addEventListener("error",function(e){e=e.error;postMessage({$e$:[e.message,e.code,e.stack]})})' + ], { type: 'text/javascript' })))); + w.onmessage = function (e) { + var d = e.data, ed = d.$e$; + if (ed) { + var err = new Error(ed[0]); + err['code'] = ed[1]; + err.stack = ed[2]; + cb(err, null); + } + else + cb(null, d); + }; + w.postMessage(msg, transfer); + return w; +}); + +// aliases for shorter compressed code (most minifers don't do this) +var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array; +// fixed length extra bits +var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]); +// fixed distance extra bits +var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]); +// code length index map +var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]); +// get base, reverse index map from extra bits +var freb = function (eb, start) { + var b = new u16(31); + for (var i = 0; i < 31; ++i) { + b[i] = start += 1 << eb[i - 1]; + } + // numbers here are at max 18 bits + var r = new i32(b[30]); + for (var i = 1; i < 30; ++i) { + for (var j = b[i]; j < b[i + 1]; ++j) { + r[j] = ((j - b[i]) << 5) | i; + } + } + return { b: b, r: r }; +}; +var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r; +// we can ignore the fact that the other numbers are wrong; they never happen anyway +fl[28] = 258, revfl[258] = 28; +var _b = freb(fdeb, 0), fd = _b.b, revfd = _b.r; +// map of value to reverse (assuming 16 bits) +var rev = new u16(32768); +for (var i = 0; i < 32768; ++i) { + // reverse table algorithm from SO + var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1); + x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2); + x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4); + rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1; +} +// create huffman tree from u8 "map": index -> code length for code index +// mb (max bits) must be at most 15 +// TODO: optimize/split up? +var hMap = (function (cd, mb, r) { + var s = cd.length; + // index + var i = 0; + // u16 "map": index -> # of codes with bit length = index + var l = new u16(mb); + // length of cd must be 288 (total # of codes) + for (; i < s; ++i) { + if (cd[i]) + ++l[cd[i] - 1]; + } + // u16 "map": index -> minimum code for bit length = index + var le = new u16(mb); + for (i = 1; i < mb; ++i) { + le[i] = (le[i - 1] + l[i - 1]) << 1; + } + var co; + if (r) { + // u16 "map": index -> number of actual bits, symbol for code + co = new u16(1 << mb); + // bits to remove for reverser + var rvb = 15 - mb; + for (i = 0; i < s; ++i) { + // ignore 0 lengths + if (cd[i]) { + // num encoding both symbol and bits read + var sv = (i << 4) | cd[i]; + // free bits + var r_1 = mb - cd[i]; + // start value + var v = le[cd[i] - 1]++ << r_1; + // m is end value + for (var m = v | ((1 << r_1) - 1); v <= m; ++v) { + // every 16 bit value starting with the code yields the same result + co[rev[v] >> rvb] = sv; + } + } + } + } + else { + co = new u16(s); + for (i = 0; i < s; ++i) { + if (cd[i]) { + co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]); + } + } + } + return co; +}); +// fixed length tree +var flt = new u8(288); +for (var i = 0; i < 144; ++i) + flt[i] = 8; +for (var i = 144; i < 256; ++i) + flt[i] = 9; +for (var i = 256; i < 280; ++i) + flt[i] = 7; +for (var i = 280; i < 288; ++i) + flt[i] = 8; +// fixed distance tree +var fdt = new u8(32); +for (var i = 0; i < 32; ++i) + fdt[i] = 5; +// fixed length map +var flm = /*#__PURE__*/ hMap(flt, 9, 0), flrm = /*#__PURE__*/ hMap(flt, 9, 1); +// fixed distance map +var fdm = /*#__PURE__*/ hMap(fdt, 5, 0), fdrm = /*#__PURE__*/ hMap(fdt, 5, 1); +// find max of array +var max = function (a) { + var m = a[0]; + for (var i = 1; i < a.length; ++i) { + if (a[i] > m) + m = a[i]; + } + return m; +}; +// read d, starting at bit p and mask with m +var bits = function (d, p, m) { + var o = (p / 8) | 0; + return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m; +}; +// read d, starting at bit p continuing for at least 16 bits +var bits16 = function (d, p) { + var o = (p / 8) | 0; + return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7)); +}; +// get end of byte +var shft = function (p) { return ((p + 7) / 8) | 0; }; +// typed array slice - allows garbage collector to free original reference, +// while being more compatible than .slice +var slc = function (v, s, e) { + if (s == null || s < 0) + s = 0; + if (e == null || e > v.length) + e = v.length; + // can't use .constructor in case user-supplied + return new u8(v.subarray(s, e)); +}; +/** + * Codes for errors generated within this library + */ +exports.FlateErrorCode = { + UnexpectedEOF: 0, + InvalidBlockType: 1, + InvalidLengthLiteral: 2, + InvalidDistance: 3, + StreamFinished: 4, + NoStreamHandler: 5, + InvalidHeader: 6, + NoCallback: 7, + InvalidUTF8: 8, + ExtraFieldTooLong: 9, + InvalidDate: 10, + FilenameTooLong: 11, + StreamFinishing: 12, + InvalidZipData: 13, + UnknownCompressionMethod: 14 +}; +// error codes +var ec = [ + 'unexpected EOF', + 'invalid block type', + 'invalid length/literal', + 'invalid distance', + 'stream finished', + 'no stream handler', + , // determined by compression function + 'no callback', + 'invalid UTF-8 data', + 'extra field too long', + 'date not in range 1980-2099', + 'filename too long', + 'stream finishing', + 'invalid zip data' + // determined by unknown compression method +]; +; +var err = function (ind, msg, nt) { + var e = new Error(msg || ec[ind]); + e.code = ind; + if (Error.captureStackTrace) + Error.captureStackTrace(e, err); + if (!nt) + throw e; + return e; +}; +// expands raw DEFLATE data +var inflt = function (dat, st, buf, dict) { + // source length dict length + var sl = dat.length, dl = dict ? dict.length : 0; + if (!sl || st.f && !st.l) + return buf || new u8(0); + var noBuf = !buf; + // have to estimate size + var resize = noBuf || st.i != 2; + // no state + var noSt = st.i; + // Assumes roughly 33% compression ratio average + if (noBuf) + buf = new u8(sl * 3); + // ensure buffer can fit at least l elements + var cbuf = function (l) { + var bl = buf.length; + // need to increase size to fit + if (l > bl) { + // Double or set to necessary, whichever is greater + var nbuf = new u8(Math.max(bl * 2, l)); + nbuf.set(buf); + buf = nbuf; + } + }; + // last chunk bitpos bytes + var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n; + // total bits + var tbts = sl * 8; + do { + if (!lm) { + // BFINAL - this is only 1 when last chunk is next + final = bits(dat, pos, 1); + // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman + var type = bits(dat, pos + 1, 3); + pos += 3; + if (!type) { + // go to end of byte boundary + var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l; + if (t > sl) { + if (noSt) + err(0); + break; + } + // ensure size + if (resize) + cbuf(bt + l); + // Copy over uncompressed data + buf.set(dat.subarray(s, t), bt); + // Get new bitpos, update byte count + st.b = bt += l, st.p = pos = t * 8, st.f = final; + continue; + } + else if (type == 1) + lm = flrm, dm = fdrm, lbt = 9, dbt = 5; + else if (type == 2) { + // literal lengths + var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4; + var tl = hLit + bits(dat, pos + 5, 31) + 1; + pos += 14; + // length+distance tree + var ldt = new u8(tl); + // code length tree + var clt = new u8(19); + for (var i = 0; i < hcLen; ++i) { + // use index map to get real code + clt[clim[i]] = bits(dat, pos + i * 3, 7); + } + pos += hcLen * 3; + // code lengths bits + var clb = max(clt), clbmsk = (1 << clb) - 1; + // code lengths map + var clm = hMap(clt, clb, 1); + for (var i = 0; i < tl;) { + var r = clm[bits(dat, pos, clbmsk)]; + // bits read + pos += r & 15; + // symbol + var s = r >> 4; + // code length to copy + if (s < 16) { + ldt[i++] = s; + } + else { + // copy count + var c = 0, n = 0; + if (s == 16) + n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1]; + else if (s == 17) + n = 3 + bits(dat, pos, 7), pos += 3; + else if (s == 18) + n = 11 + bits(dat, pos, 127), pos += 7; + while (n--) + ldt[i++] = c; + } + } + // length tree distance tree + var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit); + // max length bits + lbt = max(lt); + // max dist bits + dbt = max(dt); + lm = hMap(lt, lbt, 1); + dm = hMap(dt, dbt, 1); + } + else + err(1); + if (pos > tbts) { + if (noSt) + err(0); + break; + } + } + // Make sure the buffer can hold this + the largest possible addition + // Maximum chunk size (practically, theoretically infinite) is 2^17 + if (resize) + cbuf(bt + 131072); + var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1; + var lpos = pos; + for (;; lpos = pos) { + // bits read, code + var c = lm[bits16(dat, pos) & lms], sym = c >> 4; + pos += c & 15; + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (!c) + err(2); + if (sym < 256) + buf[bt++] = sym; + else if (sym == 256) { + lpos = pos, lm = null; + break; + } + else { + var add = sym - 254; + // no extra bits needed if less + if (sym > 264) { + // index + var i = sym - 257, b = fleb[i]; + add = bits(dat, pos, (1 << b) - 1) + fl[i]; + pos += b; + } + // dist + var d = dm[bits16(dat, pos) & dms], dsym = d >> 4; + if (!d) + err(3); + pos += d & 15; + var dt = fd[dsym]; + if (dsym > 3) { + var b = fdeb[dsym]; + dt += bits16(dat, pos) & (1 << b) - 1, pos += b; + } + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (resize) + cbuf(bt + 131072); + var end = bt + add; + if (bt < dt) { + var shift = dl - dt, dend = Math.min(dt, end); + if (shift + bt < 0) + err(3); + for (; bt < dend; ++bt) + buf[bt] = dict[shift + bt]; + } + for (; bt < end; ++bt) + buf[bt] = buf[bt - dt]; + } + } + st.l = lm, st.p = lpos, st.b = bt, st.f = final; + if (lm) + final = 1, st.m = lbt, st.d = dm, st.n = dbt; + } while (!final); + // don't reallocate for streams or user buffers + return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt); +}; +// starting at p, write the minimum number of bits that can hold v to d +var wbits = function (d, p, v) { + v <<= p & 7; + var o = (p / 8) | 0; + d[o] |= v; + d[o + 1] |= v >> 8; +}; +// starting at p, write the minimum number of bits (>8) that can hold v to d +var wbits16 = function (d, p, v) { + v <<= p & 7; + var o = (p / 8) | 0; + d[o] |= v; + d[o + 1] |= v >> 8; + d[o + 2] |= v >> 16; +}; +// creates code lengths from a frequency table +var hTree = function (d, mb) { + // Need extra info to make a tree + var t = []; + for (var i = 0; i < d.length; ++i) { + if (d[i]) + t.push({ s: i, f: d[i] }); + } + var s = t.length; + var t2 = t.slice(); + if (!s) + return { t: et, l: 0 }; + if (s == 1) { + var v = new u8(t[0].s + 1); + v[t[0].s] = 1; + return { t: v, l: 1 }; + } + t.sort(function (a, b) { return a.f - b.f; }); + // after i2 reaches last ind, will be stopped + // freq must be greater than largest possible number of symbols + t.push({ s: -1, f: 25001 }); + var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2; + t[0] = { s: -1, f: l.f + r.f, l: l, r: r }; + // efficient algorithm from UZIP.js + // i0 is lookbehind, i2 is lookahead - after processing two low-freq + // symbols that combined have high freq, will start processing i2 (high-freq, + // non-composite) symbols instead + // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/ + while (i1 != s - 1) { + l = t[t[i0].f < t[i2].f ? i0++ : i2++]; + r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++]; + t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r }; + } + var maxSym = t2[0].s; + for (var i = 1; i < s; ++i) { + if (t2[i].s > maxSym) + maxSym = t2[i].s; + } + // code lengths + var tr = new u16(maxSym + 1); + // max bits in tree + var mbt = ln(t[i1 - 1], tr, 0); + if (mbt > mb) { + // more algorithms from UZIP.js + // TODO: find out how this code works (debt) + // ind debt + var i = 0, dt = 0; + // left cost + var lft = mbt - mb, cst = 1 << lft; + t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; }); + for (; i < s; ++i) { + var i2_1 = t2[i].s; + if (tr[i2_1] > mb) { + dt += cst - (1 << (mbt - tr[i2_1])); + tr[i2_1] = mb; + } + else + break; + } + dt >>= lft; + while (dt > 0) { + var i2_2 = t2[i].s; + if (tr[i2_2] < mb) + dt -= 1 << (mb - tr[i2_2]++ - 1); + else + ++i; + } + for (; i >= 0 && dt; --i) { + var i2_3 = t2[i].s; + if (tr[i2_3] == mb) { + --tr[i2_3]; + ++dt; + } + } + mbt = mb; + } + return { t: new u8(tr), l: mbt }; +}; +// get the max length and assign length codes +var ln = function (n, l, d) { + return n.s == -1 + ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) + : (l[n.s] = d); +}; +// length codes generation +var lc = function (c) { + var s = c.length; + // Note that the semicolon was intentional + while (s && !c[--s]) + ; + var cl = new u16(++s); + // ind num streak + var cli = 0, cln = c[0], cls = 1; + var w = function (v) { cl[cli++] = v; }; + for (var i = 1; i <= s; ++i) { + if (c[i] == cln && i != s) + ++cls; + else { + if (!cln && cls > 2) { + for (; cls > 138; cls -= 138) + w(32754); + if (cls > 2) { + w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305); + cls = 0; + } + } + else if (cls > 3) { + w(cln), --cls; + for (; cls > 6; cls -= 6) + w(8304); + if (cls > 2) + w(((cls - 3) << 5) | 8208), cls = 0; + } + while (cls--) + w(cln); + cls = 1; + cln = c[i]; + } + } + return { c: cl.subarray(0, cli), n: s }; +}; +// calculate the length of output from tree, code lengths +var clen = function (cf, cl) { + var l = 0; + for (var i = 0; i < cl.length; ++i) + l += cf[i] * cl[i]; + return l; +}; +// writes a fixed block +// returns the new bit pos +var wfblk = function (out, pos, dat) { + // no need to write 00 as type: TypedArray defaults to 0 + var s = dat.length; + var o = shft(pos + 2); + out[o] = s & 255; + out[o + 1] = s >> 8; + out[o + 2] = out[o] ^ 255; + out[o + 3] = out[o + 1] ^ 255; + for (var i = 0; i < s; ++i) + out[o + i + 4] = dat[i]; + return (o + 4 + s) * 8; +}; +// writes a block +var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) { + wbits(out, p++, final); + ++lf[256]; + var _a = hTree(lf, 15), dlt = _a.t, mlb = _a.l; + var _b = hTree(df, 15), ddt = _b.t, mdb = _b.l; + var _c = lc(dlt), lclt = _c.c, nlc = _c.n; + var _d = lc(ddt), lcdt = _d.c, ndc = _d.n; + var lcfreq = new u16(19); + for (var i = 0; i < lclt.length; ++i) + ++lcfreq[lclt[i] & 31]; + for (var i = 0; i < lcdt.length; ++i) + ++lcfreq[lcdt[i] & 31]; + var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l; + var nlcc = 19; + for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc) + ; + var flen = (bl + 5) << 3; + var ftlen = clen(lf, flt) + clen(df, fdt) + eb; + var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]; + if (bs >= 0 && flen <= ftlen && flen <= dtlen) + return wfblk(out, p, dat.subarray(bs, bs + bl)); + var lm, ll, dm, dl; + wbits(out, p, 1 + (dtlen < ftlen)), p += 2; + if (dtlen < ftlen) { + lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt; + var llm = hMap(lct, mlcb, 0); + wbits(out, p, nlc - 257); + wbits(out, p + 5, ndc - 1); + wbits(out, p + 10, nlcc - 4); + p += 14; + for (var i = 0; i < nlcc; ++i) + wbits(out, p + 3 * i, lct[clim[i]]); + p += 3 * nlcc; + var lcts = [lclt, lcdt]; + for (var it = 0; it < 2; ++it) { + var clct = lcts[it]; + for (var i = 0; i < clct.length; ++i) { + var len = clct[i] & 31; + wbits(out, p, llm[len]), p += lct[len]; + if (len > 15) + wbits(out, p, (clct[i] >> 5) & 127), p += clct[i] >> 12; + } + } + } + else { + lm = flm, ll = flt, dm = fdm, dl = fdt; + } + for (var i = 0; i < li; ++i) { + var sym = syms[i]; + if (sym > 255) { + var len = (sym >> 18) & 31; + wbits16(out, p, lm[len + 257]), p += ll[len + 257]; + if (len > 7) + wbits(out, p, (sym >> 23) & 31), p += fleb[len]; + var dst = sym & 31; + wbits16(out, p, dm[dst]), p += dl[dst]; + if (dst > 3) + wbits16(out, p, (sym >> 5) & 8191), p += fdeb[dst]; + } + else { + wbits16(out, p, lm[sym]), p += ll[sym]; + } + } + wbits16(out, p, lm[256]); + return p + ll[256]; +}; +// deflate options (nice << 13) | chain +var deo = /*#__PURE__*/ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]); +// empty +var et = /*#__PURE__*/ new u8(0); +// compresses data into a raw DEFLATE buffer +var dflt = function (dat, lvl, plvl, pre, post, st) { + var s = st.z || dat.length; + var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post); + // writing to this writes to the output buffer + var w = o.subarray(pre, o.length - post); + var lst = st.l; + var pos = (st.r || 0) & 7; + if (lvl) { + if (pos) + w[0] = st.r >> 3; + var opt = deo[lvl - 1]; + var n = opt >> 13, c = opt & 8191; + var msk_1 = (1 << plvl) - 1; + // prev 2-byte val map curr 2-byte val map + var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1); + var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1; + var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; }; + // 24576 is an arbitrary number of maximum symbols per block + // 424 buffer for last block + var syms = new i32(25000); + // length/literal freq distance freq + var lf = new u16(288), df = new u16(32); + // l/lcnt exbits index l/lind waitdx blkpos + var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0; + for (; i + 2 < s; ++i) { + // hash value + var hv = hsh(i); + // index mod 32768 previous index mod + var imod = i & 32767, pimod = head[hv]; + prev[imod] = pimod; + head[hv] = imod; + // We always should modify head and prev, but only add symbols if + // this data is not yet processed ("wait" for wait index) + if (wi <= i) { + // bytes remaining + var rem = s - i; + if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) { + pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos); + li = lc_1 = eb = 0, bs = i; + for (var j = 0; j < 286; ++j) + lf[j] = 0; + for (var j = 0; j < 30; ++j) + df[j] = 0; + } + // len dist chain + var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767; + if (rem > 2 && hv == hsh(i - dif)) { + var maxn = Math.min(n, rem) - 1; + var maxd = Math.min(32767, i); + // max possible length + // not capped at dif because decompressors implement "rolling" index population + var ml = Math.min(258, rem); + while (dif <= maxd && --ch_1 && imod != pimod) { + if (dat[i + l] == dat[i + l - dif]) { + var nl = 0; + for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl) + ; + if (nl > l) { + l = nl, d = dif; + // break out early when we reach "nice" (we are satisfied enough) + if (nl > maxn) + break; + // now, find the rarest 2-byte sequence within this + // length of literals and search for that instead. + // Much faster than just using the start + var mmd = Math.min(dif, nl - 2); + var md = 0; + for (var j = 0; j < mmd; ++j) { + var ti = i - dif + j & 32767; + var pti = prev[ti]; + var cd = ti - pti & 32767; + if (cd > md) + md = cd, pimod = ti; + } + } + } + // check the previous match + imod = pimod, pimod = prev[imod]; + dif += imod - pimod & 32767; + } + } + // d will be nonzero only when a match was found + if (d) { + // store both dist and len data in one int32 + // Make sure this is recognized as a len/dist with 28th bit (2^28) + syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d]; + var lin = revfl[l] & 31, din = revfd[d] & 31; + eb += fleb[lin] + fdeb[din]; + ++lf[257 + lin]; + ++df[din]; + wi = i + l; + ++lc_1; + } + else { + syms[li++] = dat[i]; + ++lf[dat[i]]; + } + } + } + for (i = Math.max(i, wi); i < s; ++i) { + syms[li++] = dat[i]; + ++lf[dat[i]]; + } + pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos); + if (!lst) { + st.r = (pos & 7) | w[(pos / 8) | 0] << 3; + // shft(pos) now 1 less if pos & 7 != 0 + pos -= 7; + st.h = head, st.p = prev, st.i = i, st.w = wi; + } + } + else { + for (var i = st.w || 0; i < s + lst; i += 65535) { + // end + var e = i + 65535; + if (e >= s) { + // write final block + w[(pos / 8) | 0] = lst; + e = s; + } + pos = wfblk(w, pos + 1, dat.subarray(i, e)); + } + st.i = s; + } + return slc(o, 0, pre + shft(pos) + post); +}; +// CRC32 table +var crct = /*#__PURE__*/ (function () { + var t = new Int32Array(256); + for (var i = 0; i < 256; ++i) { + var c = i, k = 9; + while (--k) + c = ((c & 1) && -306674912) ^ (c >>> 1); + t[i] = c; + } + return t; +})(); +// CRC32 +var crc = function () { + var c = -1; + return { + p: function (d) { + // closures have awful performance + var cr = c; + for (var i = 0; i < d.length; ++i) + cr = crct[(cr & 255) ^ d[i]] ^ (cr >>> 8); + c = cr; + }, + d: function () { return ~c; } + }; +}; +// Adler32 +var adler = function () { + var a = 1, b = 0; + return { + p: function (d) { + // closures have awful performance + var n = a, m = b; + var l = d.length | 0; + for (var i = 0; i != l;) { + var e = Math.min(i + 2655, l); + for (; i < e; ++i) + m += n += d[i]; + n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16); + } + a = n, b = m; + }, + d: function () { + a %= 65521, b %= 65521; + return (a & 255) << 24 | (a & 0xFF00) << 8 | (b & 255) << 8 | (b >> 8); + } + }; +}; +; +// deflate with opts +var dopt = function (dat, opt, pre, post, st) { + if (!st) { + st = { l: 1 }; + if (opt.dictionary) { + var dict = opt.dictionary.subarray(-32768); + var newDat = new u8(dict.length + dat.length); + newDat.set(dict); + newDat.set(dat, dict.length); + dat = newDat; + st.w = dict.length; + } + } + return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? (st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20) : (12 + opt.mem), pre, post, st); +}; +// Walmart object spread +var mrg = function (a, b) { + var o = {}; + for (var k in a) + o[k] = a[k]; + for (var k in b) + o[k] = b[k]; + return o; +}; +// worker clone +// This is possibly the craziest part of the entire codebase, despite how simple it may seem. +// The only parameter to this function is a closure that returns an array of variables outside of the function scope. +// We're going to try to figure out the variable names used in the closure as strings because that is crucial for workerization. +// We will return an object mapping of true variable name to value (basically, the current scope as a JS object). +// The reason we can't just use the original variable names is minifiers mangling the toplevel scope. +// This took me three weeks to figure out how to do. +var wcln = function (fn, fnStr, td) { + var dt = fn(); + var st = fn.toString(); + var ks = st.slice(st.indexOf('[') + 1, st.lastIndexOf(']')).replace(/\s+/g, '').split(','); + for (var i = 0; i < dt.length; ++i) { + var v = dt[i], k = ks[i]; + if (typeof v == 'function') { + fnStr += ';' + k + '='; + var st_1 = v.toString(); + if (v.prototype) { + // for global objects + if (st_1.indexOf('[native code]') != -1) { + var spInd = st_1.indexOf(' ', 8) + 1; + fnStr += st_1.slice(spInd, st_1.indexOf('(', spInd)); + } + else { + fnStr += st_1; + for (var t in v.prototype) + fnStr += ';' + k + '.prototype.' + t + '=' + v.prototype[t].toString(); + } + } + else + fnStr += st_1; + } + else + td[k] = v; + } + return fnStr; +}; +var ch = []; +// clone bufs +var cbfs = function (v) { + var tl = []; + for (var k in v) { + if (v[k].buffer) { + tl.push((v[k] = new v[k].constructor(v[k])).buffer); + } + } + return tl; +}; +// use a worker to execute code +var wrkr = function (fns, init, id, cb) { + if (!ch[id]) { + var fnStr = '', td_1 = {}, m = fns.length - 1; + for (var i = 0; i < m; ++i) + fnStr = wcln(fns[i], fnStr, td_1); + ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 }; + } + var td = mrg({}, ch[id].e); + return (0, node_worker_1.default)(ch[id].c + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb); +}; +// base async inflate fn +var bInflt = function () { return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt]; }; +var bDflt = function () { return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; }; +// gzip extra +var gze = function () { return [gzh, gzhl, wbytes, crc, crct]; }; +// gunzip extra +var guze = function () { return [gzs, gzl]; }; +// zlib extra +var zle = function () { return [zlh, wbytes, adler]; }; +// unzlib extra +var zule = function () { return [zls]; }; +// post buf +var pbf = function (msg) { return postMessage(msg, [msg.buffer]); }; +// get opts +var gopt = function (o) { return o && { + out: o.size && new u8(o.size), + dictionary: o.dictionary +}; }; +// async helper +var cbify = function (dat, opts, fns, init, id, cb) { + var w = wrkr(fns, init, id, function (err, dat) { + w.terminate(); + cb(err, dat); + }); + w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []); + return function () { w.terminate(); }; +}; +// auto stream +var astrm = function (strm) { + strm.ondata = function (dat, final) { return postMessage([dat, final], [dat.buffer]); }; + return function (ev) { + if (ev.data[0]) { + strm.push(ev.data[0], ev.data[1]); + postMessage([ev.data[0].length]); + } + else + strm.flush(ev.data[1]); + }; +}; +// async stream attach +var astrmify = function (fns, strm, opts, init, id, flush, ext) { + var t; + var w = wrkr(fns, init, id, function (err, dat) { + if (err) + w.terminate(), strm.ondata.call(strm, err); + else if (!Array.isArray(dat)) + ext(dat); + else if (dat.length == 1) { + strm.queuedSize -= dat[0]; + if (strm.ondrain) + strm.ondrain(dat[0]); + } + else { + if (dat[1]) + w.terminate(); + strm.ondata.call(strm, err, dat[0], dat[1]); + } + }); + w.postMessage(opts); + strm.queuedSize = 0; + strm.push = function (d, f) { + if (!strm.ondata) + err(5); + if (t) + strm.ondata(err(4, 0, 1), null, !!f); + strm.queuedSize += d.length; + // can fail for cross-realm Uint8Array, but ok - only a small performance penalty + w.postMessage([d, t = f], d.buffer instanceof ArrayBuffer ? [d.buffer] : []); + }; + strm.terminate = function () { w.terminate(); }; + if (flush) { + strm.flush = function (sync) { w.postMessage([0, sync]); }; + } +}; +// read 2 bytes +var b2 = function (d, b) { return d[b] | (d[b + 1] << 8); }; +// read 4 bytes +var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; }; +// read 8 bytes +var b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); }; +// write bytes +var wbytes = function (d, b, v) { + for (; v; ++b) + d[b] = v, v >>>= 8; +}; +// gzip header +var gzh = function (c, o) { + var fn = o.filename; + c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3; // assume Unix + if (o.mtime != 0) + wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1000)); + if (fn) { + c[3] = 8; + for (var i = 0; i <= fn.length; ++i) + c[i + 10] = fn.charCodeAt(i); + } +}; +// gzip footer: -8 to -4 = CRC, -4 to -0 is length +// gzip start +var gzs = function (d) { + if (d[0] != 31 || d[1] != 139 || d[2] != 8) + err(6, 'invalid gzip data'); + var flg = d[3]; + var st = 10; + if (flg & 4) + st += (d[10] | d[11] << 8) + 2; + for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) + ; + return st + (flg & 2); +}; +// gzip length +var gzl = function (d) { + var l = d.length; + return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0; +}; +// gzip header length +var gzhl = function (o) { return 10 + (o.filename ? o.filename.length + 1 : 0); }; +// zlib header +var zlh = function (c, o) { + var lv = o.level, fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2; + c[0] = 120, c[1] = (fl << 6) | (o.dictionary && 32); + c[1] |= 31 - ((c[0] << 8) | c[1]) % 31; + if (o.dictionary) { + var h = adler(); + h.p(o.dictionary); + wbytes(c, 2, h.d()); + } +}; +// zlib start +var zls = function (d, dict) { + if ((d[0] & 15) != 8 || (d[0] >> 4) > 7 || ((d[0] << 8 | d[1]) % 31)) + err(6, 'invalid zlib data'); + if ((d[1] >> 5 & 1) == +!dict) + err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary'); + return (d[1] >> 3 & 4) + 2; +}; +function StrmOpt(opts, cb) { + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + return opts; +} +/** + * Streaming DEFLATE compression + */ +var Deflate = /*#__PURE__*/ (function () { + function Deflate(opts, cb) { + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + this.o = opts || {}; + this.s = { l: 0, i: 32768, w: 32768, z: 32768 }; + // Buffer length must always be 0 mod 32768 for index calculations to be correct when modifying head and prev + // 98304 = 32768 (lookback) + 65536 (common chunk size) + this.b = new u8(98304); + if (this.o.dictionary) { + var dict = this.o.dictionary.subarray(-32768); + this.b.set(dict, 32768 - dict.length); + this.s.i = 32768 - dict.length; + } + } + Deflate.prototype.p = function (c, f) { + this.ondata(dopt(c, this.o, 0, 0, this.s), f); + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Deflate.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (this.s.l) + err(4); + var endLen = chunk.length + this.s.z; + if (endLen > this.b.length) { + if (endLen > 2 * this.b.length - 32768) { + var newBuf = new u8(endLen & -32768); + newBuf.set(this.b.subarray(0, this.s.z)); + this.b = newBuf; + } + var split = this.b.length - this.s.z; + this.b.set(chunk.subarray(0, split), this.s.z); + this.s.z = this.b.length; + this.p(this.b, false); + this.b.set(this.b.subarray(-32768)); + this.b.set(chunk.subarray(split), 32768); + this.s.z = chunk.length - split + 32768; + this.s.i = 32766, this.s.w = 32768; + } + else { + this.b.set(chunk, this.s.z); + this.s.z += chunk.length; + } + this.s.l = final & 1; + if (this.s.z > this.s.w + 8191 || final) { + this.p(this.b, final || false); + this.s.w = this.s.i, this.s.i -= 2; + } + if (final) { + // cleanup unneeded buffers/state to reduce memory usage + this.s = this.o = {}; + this.b = et; + } + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + Deflate.prototype.flush = function (sync) { + if (!this.ondata) + err(5); + if (this.s.l) + err(4); + this.p(this.b, false); + this.s.w = this.s.i, this.s.i -= 2; + // could technically skip writing the type-0 block for (this.s.r & 7) == 0, + // but the deterministic trailer (00 00 FF FF) is useful in some situations + if (sync) { + var c = new u8(6); + c[0] = this.s.r >> 3; + // write empty, non-final type-0 block + var ep = wfblk(c, this.s.r, et); + this.s.r = 0; + this.ondata(c.subarray(0, ep >> 3), false); + } + }; + return Deflate; +}()); +exports.Deflate = Deflate; +/** + * Asynchronous streaming DEFLATE compression + */ +var AsyncDeflate = /*#__PURE__*/ (function () { + function AsyncDeflate(opts, cb) { + astrmify([ + bDflt, + function () { return [astrm, Deflate]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Deflate(ev.data); + onmessage = astrm(strm); + }, 6, 1); + } + return AsyncDeflate; +}()); +exports.AsyncDeflate = AsyncDeflate; +function deflate(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + ], function (ev) { return pbf(deflateSync(ev.data[0], ev.data[1])); }, 0, cb); +} +/** + * Compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @returns The deflated version of the data + */ +function deflateSync(data, opts) { + return dopt(data, opts || {}, 0, 0); +} +/** + * Streaming DEFLATE decompression + */ +var Inflate = /*#__PURE__*/ (function () { + function Inflate(opts, cb) { + // no StrmOpt here to avoid adding to workerizer + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768); + this.s = { i: 0, b: dict ? dict.length : 0 }; + this.o = new u8(32768); + this.p = new u8(0); + if (dict) + this.o.set(dict); + } + Inflate.prototype.e = function (c) { + if (!this.ondata) + err(5); + if (this.d) + err(4); + if (!this.p.length) + this.p = c; + else if (c.length) { + var n = new u8(this.p.length + c.length); + n.set(this.p), n.set(c, this.p.length), this.p = n; + } + }; + Inflate.prototype.c = function (final) { + this.s.i = +(this.d = final || false); + var bts = this.s.b; + var dt = inflt(this.p, this.s, this.o); + this.ondata(slc(dt, bts, this.s.b), this.d); + this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length; + this.p = slc(this.p, (this.s.p / 8) | 0), this.s.p &= 7; + }; + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the final chunk + */ + Inflate.prototype.push = function (chunk, final) { + this.e(chunk), this.c(final); + }; + return Inflate; +}()); +exports.Inflate = Inflate; +/** + * Asynchronous streaming DEFLATE decompression + */ +var AsyncInflate = /*#__PURE__*/ (function () { + function AsyncInflate(opts, cb) { + astrmify([ + bInflt, + function () { return [astrm, Inflate]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Inflate(ev.data); + onmessage = astrm(strm); + }, 7, 0); + } + return AsyncInflate; +}()); +exports.AsyncInflate = AsyncInflate; +function inflate(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt + ], function (ev) { return pbf(inflateSync(ev.data[0], gopt(ev.data[1]))); }, 1, cb); +} +function inflateSync(data, opts) { + return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary); +} +// before you yell at me for not just using extends, my reason is that TS inheritance is hard to workerize. +/** + * Streaming GZIP compression + */ +var Gzip = /*#__PURE__*/ (function () { + function Gzip(opts, cb) { + this.c = crc(); + this.l = 0; + this.v = 1; + Deflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Gzip.prototype.push = function (chunk, final) { + this.c.p(chunk); + this.l += chunk.length; + Deflate.prototype.push.call(this, chunk, final); + }; + Gzip.prototype.p = function (c, f) { + var raw = dopt(c, this.o, this.v && gzhl(this.o), f && 8, this.s); + if (this.v) + gzh(raw, this.o), this.v = 0; + if (f) + wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l); + this.ondata(raw, f); + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + Gzip.prototype.flush = function (sync) { + Deflate.prototype.flush.call(this, sync); + }; + return Gzip; +}()); +exports.Gzip = Gzip; +exports.Compress = Gzip; +/** + * Asynchronous streaming GZIP compression + */ +var AsyncGzip = /*#__PURE__*/ (function () { + function AsyncGzip(opts, cb) { + astrmify([ + bDflt, + gze, + function () { return [astrm, Deflate, Gzip]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Gzip(ev.data); + onmessage = astrm(strm); + }, 8, 1); + } + return AsyncGzip; +}()); +exports.AsyncGzip = AsyncGzip; +exports.AsyncCompress = AsyncGzip; +function gzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + gze, + function () { return [gzipSync]; } + ], function (ev) { return pbf(gzipSync(ev.data[0], ev.data[1])); }, 2, cb); +} +/** + * Compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @returns The gzipped version of the data + */ +function gzipSync(data, opts) { + if (!opts) + opts = {}; + var c = crc(), l = data.length; + c.p(data); + var d = dopt(data, opts, gzhl(opts), 8), s = d.length; + return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d; +} +/** + * Streaming single or multi-member GZIP decompression + */ +var Gunzip = /*#__PURE__*/ (function () { + function Gunzip(opts, cb) { + this.v = 1; + this.r = 0; + Inflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Gunzip.prototype.push = function (chunk, final) { + Inflate.prototype.e.call(this, chunk); + this.r += chunk.length; + if (this.v) { + var p = this.p.subarray(this.v - 1); + var s = p.length > 3 ? gzs(p) : 4; + if (s > p.length) { + if (!final) + return; + } + else if (this.v > 1 && this.onmember) { + this.onmember(this.r - p.length); + } + this.p = p.subarray(s), this.v = 0; + } + // necessary to prevent TS from using the closure value + // This allows for workerization to function correctly + Inflate.prototype.c.call(this, 0); + // process concatenated GZIP + if (this.s.f && !this.s.l) { + this.v = shft(this.s.p) + 9; + this.s = { i: 0 }; + this.o = new u8(0); + this.push(new u8(0), final); + } + else if (final) { + Inflate.prototype.c.call(this, final); + } + }; + return Gunzip; +}()); +exports.Gunzip = Gunzip; +/** + * Asynchronous streaming single or multi-member GZIP decompression + */ +var AsyncGunzip = /*#__PURE__*/ (function () { + function AsyncGunzip(opts, cb) { + var _this = this; + astrmify([ + bInflt, + guze, + function () { return [astrm, Inflate, Gunzip]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Gunzip(ev.data); + strm.onmember = function (offset) { return postMessage(offset); }; + onmessage = astrm(strm); + }, 9, 0, function (offset) { return _this.onmember && _this.onmember(offset); }); + } + return AsyncGunzip; +}()); +exports.AsyncGunzip = AsyncGunzip; +function gunzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt, + guze, + function () { return [gunzipSync]; } + ], function (ev) { return pbf(gunzipSync(ev.data[0], ev.data[1])); }, 3, cb); +} +function gunzipSync(data, opts) { + var st = gzs(data); + if (st + 8 > data.length) + err(6, 'invalid gzip data'); + return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary); +} +/** + * Streaming Zlib compression + */ +var Zlib = /*#__PURE__*/ (function () { + function Zlib(opts, cb) { + this.c = adler(); + this.v = 1; + Deflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be zlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Zlib.prototype.push = function (chunk, final) { + this.c.p(chunk); + Deflate.prototype.push.call(this, chunk, final); + }; + Zlib.prototype.p = function (c, f) { + var raw = dopt(c, this.o, this.v && (this.o.dictionary ? 6 : 2), f && 4, this.s); + if (this.v) + zlh(raw, this.o), this.v = 0; + if (f) + wbytes(raw, raw.length - 4, this.c.d()); + this.ondata(raw, f); + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + Zlib.prototype.flush = function (sync) { + Deflate.prototype.flush.call(this, sync); + }; + return Zlib; +}()); +exports.Zlib = Zlib; +/** + * Asynchronous streaming Zlib compression + */ +var AsyncZlib = /*#__PURE__*/ (function () { + function AsyncZlib(opts, cb) { + astrmify([ + bDflt, + zle, + function () { return [astrm, Deflate, Zlib]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Zlib(ev.data); + onmessage = astrm(strm); + }, 10, 1); + } + return AsyncZlib; +}()); +exports.AsyncZlib = AsyncZlib; +function zlib(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + zle, + function () { return [zlibSync]; } + ], function (ev) { return pbf(zlibSync(ev.data[0], ev.data[1])); }, 4, cb); +} +/** + * Compress data with Zlib + * @param data The data to compress + * @param opts The compression options + * @returns The zlib-compressed version of the data + */ +function zlibSync(data, opts) { + if (!opts) + opts = {}; + var a = adler(); + a.p(data); + var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4); + return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d; +} +/** + * Streaming Zlib decompression + */ +var Unzlib = /*#__PURE__*/ (function () { + function Unzlib(opts, cb) { + Inflate.call(this, opts, cb); + this.v = opts && opts.dictionary ? 2 : 1; + } + /** + * Pushes a chunk to be unzlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Unzlib.prototype.push = function (chunk, final) { + Inflate.prototype.e.call(this, chunk); + if (this.v) { + if (this.p.length < 6 && !final) + return; + this.p = this.p.subarray(zls(this.p, this.v - 1)), this.v = 0; + } + if (final) { + if (this.p.length < 4) + err(6, 'invalid zlib data'); + this.p = this.p.subarray(0, -4); + } + // necessary to prevent TS from using the closure value + // This allows for workerization to function correctly + Inflate.prototype.c.call(this, final); + }; + return Unzlib; +}()); +exports.Unzlib = Unzlib; +/** + * Asynchronous streaming Zlib decompression + */ +var AsyncUnzlib = /*#__PURE__*/ (function () { + function AsyncUnzlib(opts, cb) { + astrmify([ + bInflt, + zule, + function () { return [astrm, Inflate, Unzlib]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Unzlib(ev.data); + onmessage = astrm(strm); + }, 11, 0); + } + return AsyncUnzlib; +}()); +exports.AsyncUnzlib = AsyncUnzlib; +function unzlib(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt, + zule, + function () { return [unzlibSync]; } + ], function (ev) { return pbf(unzlibSync(ev.data[0], gopt(ev.data[1]))); }, 5, cb); +} +function unzlibSync(data, opts) { + return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary); +} +/** + * Streaming GZIP, Zlib, or raw DEFLATE decompression + */ +var Decompress = /*#__PURE__*/ (function () { + function Decompress(opts, cb) { + this.o = StrmOpt.call(this, opts, cb) || {}; + this.G = Gunzip; + this.I = Inflate; + this.Z = Unzlib; + } + // init substream + // overriden by AsyncDecompress + Decompress.prototype.i = function () { + var _this = this; + this.s.ondata = function (dat, final) { + _this.ondata(dat, final); + }; + }; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Decompress.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (!this.s) { + if (this.p && this.p.length) { + var n = new u8(this.p.length + chunk.length); + n.set(this.p), n.set(chunk, this.p.length); + } + else + this.p = chunk; + if (this.p.length > 2) { + this.s = (this.p[0] == 31 && this.p[1] == 139 && this.p[2] == 8) + ? new this.G(this.o) + : ((this.p[0] & 15) != 8 || (this.p[0] >> 4) > 7 || ((this.p[0] << 8 | this.p[1]) % 31)) + ? new this.I(this.o) + : new this.Z(this.o); + this.i(); + this.s.push(this.p, final); + this.p = null; + } + } + else + this.s.push(chunk, final); + }; + return Decompress; +}()); +exports.Decompress = Decompress; +/** + * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression + */ +var AsyncDecompress = /*#__PURE__*/ (function () { + function AsyncDecompress(opts, cb) { + Decompress.call(this, opts, cb); + this.queuedSize = 0; + this.G = AsyncGunzip; + this.I = AsyncInflate; + this.Z = AsyncUnzlib; + } + AsyncDecompress.prototype.i = function () { + var _this = this; + this.s.ondata = function (err, dat, final) { + _this.ondata(err, dat, final); + }; + this.s.ondrain = function (size) { + _this.queuedSize -= size; + if (_this.ondrain) + _this.ondrain(size); + }; + }; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + AsyncDecompress.prototype.push = function (chunk, final) { + this.queuedSize += chunk.length; + Decompress.prototype.push.call(this, chunk, final); + }; + return AsyncDecompress; +}()); +exports.AsyncDecompress = AsyncDecompress; +function decompress(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return (data[0] == 31 && data[1] == 139 && data[2] == 8) + ? gunzip(data, opts, cb) + : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31)) + ? inflate(data, opts, cb) + : unzlib(data, opts, cb); +} +/** + * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +function decompressSync(data, opts) { + return (data[0] == 31 && data[1] == 139 && data[2] == 8) + ? gunzipSync(data, opts) + : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31)) + ? inflateSync(data, opts) + : unzlibSync(data, opts); +} +// flatten a directory structure +var fltn = function (d, p, t, o) { + for (var k in d) { + var val = d[k], n = p + k, op = o; + if (Array.isArray(val)) + op = mrg(o, val[1]), val = val[0]; + if (ArrayBuffer.isView(val)) + t[n] = [val, op]; + else { + t[n += '/'] = [new u8(0), op]; + fltn(val, n, t, o); + } + } +}; +// text encoder +var te = typeof TextEncoder != 'undefined' && /*#__PURE__*/ new TextEncoder(); +// text decoder +var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder(); +// text decoder stream +var tds = 0; +try { + td.decode(et, { stream: true }); + tds = 1; +} +catch (e) { } +// decode UTF8 +var dutf8 = function (d) { + for (var r = '', i = 0;;) { + var c = d[i++]; + var eb = (c > 127) + (c > 223) + (c > 239); + if (i + eb > d.length) + return { s: r, r: slc(d, i - 1) }; + if (!eb) + r += String.fromCharCode(c); + else if (eb == 3) { + c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536, + r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023)); + } + else if (eb & 1) + r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63)); + else + r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)); + } +}; +/** + * Streaming UTF-8 decoding + */ +var DecodeUTF8 = /*#__PURE__*/ (function () { + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is decoded + */ + function DecodeUTF8(cb) { + this.ondata = cb; + if (tds) + this.t = new TextDecoder(); + else + this.p = et; + } + /** + * Pushes a chunk to be decoded from UTF-8 binary + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + DecodeUTF8.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + final = !!final; + if (this.t) { + this.ondata(this.t.decode(chunk, { stream: true }), final); + if (final) { + if (this.t.decode().length) + err(8); + this.t = null; + } + return; + } + if (!this.p) + err(4); + var dat = new u8(this.p.length + chunk.length); + dat.set(this.p); + dat.set(chunk, this.p.length); + var _a = dutf8(dat), s = _a.s, r = _a.r; + if (final) { + if (r.length) + err(8); + this.p = null; + } + else + this.p = r; + this.ondata(s, final); + }; + return DecodeUTF8; +}()); +exports.DecodeUTF8 = DecodeUTF8; +/** + * Streaming UTF-8 encoding + */ +var EncodeUTF8 = /*#__PURE__*/ (function () { + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is encoded + */ + function EncodeUTF8(cb) { + this.ondata = cb; + } + /** + * Pushes a chunk to be encoded to UTF-8 + * @param chunk The string data to push + * @param final Whether this is the last chunk + */ + EncodeUTF8.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (this.d) + err(4); + this.ondata(strToU8(chunk), this.d = final || false); + }; + return EncodeUTF8; +}()); +exports.EncodeUTF8 = EncodeUTF8; +/** + * Converts a string into a Uint8Array for use with compression/decompression methods + * @param str The string to encode + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless decoding a binary string. + * @returns The string encoded in UTF-8/Latin-1 binary + */ +function strToU8(str, latin1) { + if (latin1) { + var ar_1 = new u8(str.length); + for (var i = 0; i < str.length; ++i) + ar_1[i] = str.charCodeAt(i); + return ar_1; + } + if (te) + return te.encode(str); + var l = str.length; + var ar = new u8(str.length + (str.length >> 1)); + var ai = 0; + var w = function (v) { ar[ai++] = v; }; + for (var i = 0; i < l; ++i) { + if (ai + 5 > ar.length) { + var n = new u8(ai + 8 + ((l - i) << 1)); + n.set(ar); + ar = n; + } + var c = str.charCodeAt(i); + if (c < 128 || latin1) + w(c); + else if (c < 2048) + w(192 | (c >> 6)), w(128 | (c & 63)); + else if (c > 55295 && c < 57344) + c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023), + w(240 | (c >> 18)), w(128 | ((c >> 12) & 63)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63)); + else + w(224 | (c >> 12)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63)); + } + return slc(ar, 0, ai); +} +/** + * Converts a Uint8Array to a string + * @param dat The data to decode to string + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless encoding to binary string. + * @returns The original UTF-8/Latin-1 string + */ +function strFromU8(dat, latin1) { + if (latin1) { + var r = ''; + for (var i = 0; i < dat.length; i += 16384) + r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384)); + return r; + } + else if (td) { + return td.decode(dat); + } + else { + var _a = dutf8(dat), s = _a.s, r = _a.r; + if (r.length) + err(8); + return s; + } +} +; +// deflate bit flag +var dbf = function (l) { return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0; }; +// skip local zip header +var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); }; +// read zip header +var zh = function (d, b, z) { + var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl; + var _a = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a[0], su = _a[1], off = _a[2]; + return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off]; +}; +// read zip64 header sizes +var z64hs = function (d, b, l, z, sc, su, off) { + var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l; + var nf = nsc + nsu + noff; + if (z && nf) { + for (; b + 4 < e; b += 4 + b2(d, b + 2)) { + if (b2(d, b) == 1) { + return [ + nsc ? b8(d, b + 4 + 8 * nsu) : sc, + nsu ? b8(d, b + 4) : su, + noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off, + 1 + ]; + } + } + // z == 2 for unknown whether or not zip64 + if (z < 2) + err(13); + } + return [sc, su, off, 0]; +}; +// extra field length +var exfl = function (ex) { + var le = 0; + if (ex) { + for (var k in ex) { + var l = ex[k].length; + if (l > 65535) + err(9); + le += l + 4; + } + } + return le; +}; +// write zip header +var wzh = function (d, b, f, fn, u, c, ce, co) { + var fl = fn.length, ex = f.extra, col = co && co.length; + var exl = exfl(ex); + wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4; + if (ce != null) + d[b++] = 20, d[b++] = f.os; + d[b] = 20, b += 2; // spec compliance? what's that? + d[b++] = (f.flag << 1) | (c < 0 && 8), d[b++] = u && 8; + d[b++] = f.compression & 255, d[b++] = f.compression >> 8; + var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980; + if (y < 0 || y > 119) + err(10); + wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >> 1)), b += 4; + if (c != -1) { + wbytes(d, b, f.crc); + wbytes(d, b + 4, c < 0 ? -c - 2 : c); + wbytes(d, b + 8, f.size); + } + wbytes(d, b + 12, fl); + wbytes(d, b + 14, exl), b += 16; + if (ce != null) { + wbytes(d, b, col); + wbytes(d, b + 6, f.attrs); + wbytes(d, b + 10, ce), b += 14; + } + d.set(fn, b); + b += fl; + if (exl) { + for (var k in ex) { + var exf = ex[k], l = exf.length; + wbytes(d, b, +k); + wbytes(d, b + 2, l); + d.set(exf, b + 4), b += 4 + l; + } + } + if (col) + d.set(co, b), b += col; + return b; +}; +// write zip footer (end of central directory) +var wzf = function (o, b, c, d, e) { + wbytes(o, b, 0x6054B50); // skip disk + wbytes(o, b + 8, c); + wbytes(o, b + 10, c); + wbytes(o, b + 12, d); + wbytes(o, b + 16, e); +}; +/** + * A pass-through stream to keep data uncompressed in a ZIP archive. + */ +var ZipPassThrough = /*#__PURE__*/ (function () { + /** + * Creates a pass-through stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + */ + function ZipPassThrough(filename) { + this.filename = filename; + this.c = crc(); + this.size = 0; + this.compression = 0; + } + /** + * Processes a chunk and pushes to the output stream. You can override this + * method in a subclass for custom behavior, but by default this passes + * the data through. You must call this.ondata(err, chunk, final) at some + * point in this method. + * @param chunk The chunk to process + * @param final Whether this is the last chunk + */ + ZipPassThrough.prototype.process = function (chunk, final) { + this.ondata(null, chunk, final); + }; + /** + * Pushes a chunk to be added. If you are subclassing this with a custom + * compression algorithm, note that you must push data from the source + * file only, pre-compression. + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + ZipPassThrough.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + this.c.p(chunk); + this.size += chunk.length; + if (final) + this.crc = this.c.d(); + // we shouldn't really do this cast, but properly handling ArrayBufferLike + // makes the API unergonomic with Buffer + this.process(chunk, final || false); + }; + return ZipPassThrough; +}()); +exports.ZipPassThrough = ZipPassThrough; +// I don't extend because TypeScript extension adds 1kB of runtime bloat +/** + * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate + * for better performance + */ +var ZipDeflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + function ZipDeflate(filename, opts) { + var _this = this; + if (!opts) + opts = {}; + ZipPassThrough.call(this, filename); + this.d = new Deflate(opts, function (dat, final) { + _this.ondata(null, dat, final); + }); + this.compression = 8; + this.flag = dbf(opts.level); + } + ZipDeflate.prototype.process = function (chunk, final) { + try { + this.d.push(chunk, final); + } + catch (e) { + this.ondata(e, null, final); + } + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + ZipDeflate.prototype.push = function (chunk, final) { + ZipPassThrough.prototype.push.call(this, chunk, final); + }; + return ZipDeflate; +}()); +exports.ZipDeflate = ZipDeflate; +/** + * Asynchronous streaming DEFLATE compression for ZIP archives + */ +var AsyncZipDeflate = /*#__PURE__*/ (function () { + /** + * Creates an asynchronous DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + function AsyncZipDeflate(filename, opts) { + var _this = this; + if (!opts) + opts = {}; + ZipPassThrough.call(this, filename); + this.d = new AsyncDeflate(opts, function (err, dat, final) { + _this.ondata(err, dat, final); + }); + this.compression = 8; + this.flag = dbf(opts.level); + this.terminate = this.d.terminate; + } + AsyncZipDeflate.prototype.process = function (chunk, final) { + this.d.push(chunk, final); + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + AsyncZipDeflate.prototype.push = function (chunk, final) { + ZipPassThrough.prototype.push.call(this, chunk, final); + }; + return AsyncZipDeflate; +}()); +exports.AsyncZipDeflate = AsyncZipDeflate; +// TODO: Better tree shaking +/** + * A zippable archive to which files can incrementally be added + */ +var Zip = /*#__PURE__*/ (function () { + /** + * Creates an empty ZIP archive to which files can be added + * @param cb The callback to call whenever data for the generated ZIP archive + * is available + */ + function Zip(cb) { + this.ondata = cb; + this.u = []; + this.d = 1; + } + /** + * Adds a file to the ZIP archive + * @param file The file stream to add + */ + Zip.prototype.add = function (file) { + var _this = this; + if (!this.ondata) + err(5); + // finishing or finished + if (this.d & 2) + this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, false); + else { + var f = strToU8(file.filename), fl_1 = f.length; + var com = file.comment, o = com && strToU8(com); + var u = fl_1 != file.filename.length || (o && (com.length != o.length)); + var hl_1 = fl_1 + exfl(file.extra) + 30; + if (fl_1 > 65535) + this.ondata(err(11, 0, 1), null, false); + var header = new u8(hl_1); + wzh(header, 0, file, f, u, -1); + var chks_1 = [header]; + var pAll_1 = function () { + for (var _i = 0, chks_2 = chks_1; _i < chks_2.length; _i++) { + var chk = chks_2[_i]; + _this.ondata(null, chk, false); + } + chks_1 = []; + }; + var tr_1 = this.d; + this.d = 0; + var ind_1 = this.u.length; + var uf_1 = mrg(file, { + f: f, + u: u, + o: o, + t: function () { + if (file.terminate) + file.terminate(); + }, + r: function () { + pAll_1(); + if (tr_1) { + var nxt = _this.u[ind_1 + 1]; + if (nxt) + nxt.r(); + else + _this.d = 1; + } + tr_1 = 1; + } + }); + var cl_1 = 0; + file.ondata = function (err, dat, final) { + if (err) { + _this.ondata(err, dat, final); + _this.terminate(); + } + else { + cl_1 += dat.length; + chks_1.push(dat); + if (final) { + var dd = new u8(16); + wbytes(dd, 0, 0x8074B50); + wbytes(dd, 4, file.crc); + wbytes(dd, 8, cl_1); + wbytes(dd, 12, file.size); + chks_1.push(dd); + uf_1.c = cl_1, uf_1.b = hl_1 + cl_1 + 16, uf_1.crc = file.crc, uf_1.size = file.size; + if (tr_1) + uf_1.r(); + tr_1 = 1; + } + else if (tr_1) + pAll_1(); + } + }; + this.u.push(uf_1); + } + }; + /** + * Ends the process of adding files and prepares to emit the final chunks. + * This *must* be called after adding all desired files for the resulting + * ZIP file to work properly. + */ + Zip.prototype.end = function () { + var _this = this; + if (this.d & 2) { + this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, true); + return; + } + if (this.d) + this.e(); + else + this.u.push({ + r: function () { + if (!(_this.d & 1)) + return; + _this.u.splice(-1, 1); + _this.e(); + }, + t: function () { } + }); + this.d = 3; + }; + Zip.prototype.e = function () { + var bt = 0, l = 0, tl = 0; + for (var _i = 0, _a = this.u; _i < _a.length; _i++) { + var f = _a[_i]; + tl += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0); + } + var out = new u8(tl + 22); + for (var _b = 0, _c = this.u; _b < _c.length; _b++) { + var f = _c[_b]; + wzh(out, bt, f, f.f, f.u, -f.c - 2, l, f.o); + bt += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0), l += f.b; + } + wzf(out, bt, this.u.length, tl, l); + this.ondata(null, out, true); + this.d = 2; + }; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to add() will fail. + */ + Zip.prototype.terminate = function () { + for (var _i = 0, _a = this.u; _i < _a.length; _i++) { + var f = _a[_i]; + f.t(); + } + this.d = 2; + }; + return Zip; +}()); +exports.Zip = Zip; +function zip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + var r = {}; + fltn(data, '', r, opts); + var k = Object.keys(r); + var lft = k.length, o = 0, tot = 0; + var slft = lft, files = new Array(lft); + var term = []; + var tAll = function () { + for (var i = 0; i < term.length; ++i) + term[i](); + }; + var cbd = function (a, b) { + mt(function () { cb(a, b); }); + }; + mt(function () { cbd = cb; }); + var cbf = function () { + var out = new u8(tot + 22), oe = o, cdl = tot - o; + tot = 0; + for (var i = 0; i < slft; ++i) { + var f = files[i]; + try { + var l = f.c.length; + wzh(out, tot, f, f.f, f.u, l); + var badd = 30 + f.f.length + exfl(f.extra); + var loc = tot + badd; + out.set(f.c, loc); + wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l; + } + catch (e) { + return cbd(e, null); + } + } + wzf(out, o, files.length, cdl, oe); + cbd(null, out); + }; + if (!lft) + cbf(); + var _loop_1 = function (i) { + var fn = k[i]; + var _a = r[fn], file = _a[0], p = _a[1]; + var c = crc(), size = file.length; + c.p(file); + var f = strToU8(fn), s = f.length; + var com = p.comment, m = com && strToU8(com), ms = m && m.length; + var exl = exfl(p.extra); + var compression = p.level == 0 ? 0 : 8; + var cbl = function (e, d) { + if (e) { + tAll(); + cbd(e, null); + } + else { + var l = d.length; + files[i] = mrg(p, { + size: size, + crc: c.d(), + c: d, + f: f, + m: m, + u: s != fn.length || (m && (com.length != ms)), + compression: compression + }); + o += 30 + s + exl + l; + tot += 76 + 2 * (s + exl) + (ms || 0) + l; + if (!--lft) + cbf(); + } + }; + if (s > 65535) + cbl(err(11, 0, 1), null); + if (!compression) + cbl(null, file); + else if (size < 160000) { + try { + cbl(null, deflateSync(file, p)); + } + catch (e) { + cbl(e, null); + } + } + else + term.push(deflate(file, p, cbl)); + }; + // Cannot use lft because it can decrease + for (var i = 0; i < slft; ++i) { + _loop_1(i); + } + return tAll; +} +/** + * Synchronously creates a ZIP file. Prefer using `zip` for better performance + * with more than one file. + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @returns The generated ZIP archive + */ +function zipSync(data, opts) { + if (!opts) + opts = {}; + var r = {}; + var files = []; + fltn(data, '', r, opts); + var o = 0; + var tot = 0; + for (var fn in r) { + var _a = r[fn], file = _a[0], p = _a[1]; + var compression = p.level == 0 ? 0 : 8; + var f = strToU8(fn), s = f.length; + var com = p.comment, m = com && strToU8(com), ms = m && m.length; + var exl = exfl(p.extra); + if (s > 65535) + err(11); + var d = compression ? deflateSync(file, p) : file, l = d.length; + var c = crc(); + c.p(file); + files.push(mrg(p, { + size: file.length, + crc: c.d(), + c: d, + f: f, + m: m, + u: s != fn.length || (m && (com.length != ms)), + o: o, + compression: compression + })); + o += 30 + s + exl + l; + tot += 76 + 2 * (s + exl) + (ms || 0) + l; + } + var out = new u8(tot + 22), oe = o, cdl = tot - o; + for (var i = 0; i < files.length; ++i) { + var f = files[i]; + wzh(out, f.o, f, f.f, f.u, f.c.length); + var badd = 30 + f.f.length + exfl(f.extra); + out.set(f.c, f.o + badd); + wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0); + } + wzf(out, o, files.length, cdl, oe); + return out; +} +/** + * Streaming pass-through decompression for ZIP archives + */ +var UnzipPassThrough = /*#__PURE__*/ (function () { + function UnzipPassThrough() { + } + UnzipPassThrough.prototype.push = function (chunk, final) { + // same as ZipPassThrough: cast to retain Buffer ergonomics + this.ondata(null, chunk, final); + }; + UnzipPassThrough.compression = 0; + return UnzipPassThrough; +}()); +exports.UnzipPassThrough = UnzipPassThrough; +/** + * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for + * better performance. + */ +var UnzipInflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + function UnzipInflate() { + var _this = this; + this.i = new Inflate(function (dat, final) { + _this.ondata(null, dat, final); + }); + } + UnzipInflate.prototype.push = function (chunk, final) { + try { + this.i.push(chunk, final); + } + catch (e) { + this.ondata(e, null, final); + } + }; + UnzipInflate.compression = 8; + return UnzipInflate; +}()); +exports.UnzipInflate = UnzipInflate; +/** + * Asynchronous streaming DEFLATE decompression for ZIP archives + */ +var AsyncUnzipInflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + function AsyncUnzipInflate(_, sz) { + var _this = this; + if (sz < 320000) { + this.i = new Inflate(function (dat, final) { + _this.ondata(null, dat, final); + }); + } + else { + this.i = new AsyncInflate(function (err, dat, final) { + _this.ondata(err, dat, final); + }); + this.terminate = this.i.terminate; + } + } + AsyncUnzipInflate.prototype.push = function (chunk, final) { + if (this.i.terminate) + chunk = slc(chunk, 0); + this.i.push(chunk, final); + }; + AsyncUnzipInflate.compression = 8; + return AsyncUnzipInflate; +}()); +exports.AsyncUnzipInflate = AsyncUnzipInflate; +/** + * A ZIP archive decompression stream that emits files as they are discovered + */ +var Unzip = /*#__PURE__*/ (function () { + /** + * Creates a ZIP decompression stream + * @param cb The callback to call whenever a file in the ZIP archive is found + */ + function Unzip(cb) { + this.onfile = cb; + this.k = []; + this.o = { + 0: UnzipPassThrough + }; + this.p = et; + } + /** + * Pushes a chunk to be unzipped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Unzip.prototype.push = function (chunk, final) { + var _this = this; + if (!this.onfile) + err(5); + if (!this.p) + err(4); + if (this.c > 0) { + var len = Math.min(this.c, chunk.length); + var toAdd = chunk.subarray(0, len); + this.c -= len; + if (this.d) + this.d.push(toAdd, !this.c); + else + this.k[0].push(toAdd); + chunk = chunk.subarray(len); + if (chunk.length) + return this.push(chunk, final); + } + else { + var f = 0, i = 0, is = void 0, buf = void 0; + if (!this.p.length) + buf = chunk; + else if (!chunk.length) + buf = this.p; + else { + buf = new u8(this.p.length + chunk.length); + buf.set(this.p), buf.set(chunk, this.p.length); + } + var l = buf.length, oc = this.c, add = oc && this.d; + var _loop_2 = function () { + var sig = b4(buf, i); + if (sig == 0x4034B50) { + f = 1, is = i; + this_1.d = null; + this_1.c = 0; + var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28); + if (l > i + 30 + fnl + es) { + var chks_3 = []; + this_1.k.unshift(chks_3); + f = 2; + var lsc = b4(buf, i + 18), lsu = b4(buf, i + 22); + var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u); + var _a = z64hs(buf, i, es, 2, lsc, lsu, 0), sc_1 = _a[0], su_1 = _a[1], z64 = _a[3]; + if (dd) + sc_1 = -1 - z64; + i += es; + this_1.c = sc_1; + var d_1; + var file_1 = { + name: fn_1, + compression: cmp_1, + start: function () { + if (!file_1.ondata) + err(5); + if (!sc_1) + file_1.ondata(null, et, true); + else { + var ctr = _this.o[cmp_1]; + if (!ctr) + file_1.ondata(err(14, 'unknown compression type ' + cmp_1, 1), null, false); + d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1); + d_1.ondata = function (err, dat, final) { file_1.ondata(err, dat, final); }; + for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) { + var dat = chks_4[_i]; + d_1.push(dat, false); + } + if (_this.k[0] == chks_3 && _this.c) + _this.d = d_1; + else + d_1.push(et, true); + } + }, + terminate: function () { + if (d_1 && d_1.terminate) + d_1.terminate(); + } + }; + if (sc_1 >= 0) + file_1.size = sc_1, file_1.originalSize = su_1; + this_1.onfile(file_1); + } + return "break"; + } + else if (oc) { + if (sig == 0x8074B50) { + is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0; + return "break"; + } + else if (sig == 0x2014B50) { + is = i -= 4, f = 3, this_1.c = 0; + return "break"; + } + } + }; + var this_1 = this; + for (; i < l - 4; ++i) { + var state_1 = _loop_2(); + if (state_1 === "break") + break; + } + this.p = et; + if (oc < 0) { + var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 0x8074B50 && 4)) : buf.subarray(0, i); + if (add) + add.push(dat, !!f); + else + this.k[+(f == 2)].push(dat); + } + if (f & 2) + return this.push(buf.subarray(i), final); + this.p = buf.subarray(i); + } + if (final) { + if (this.c) + err(13); + this.p = null; + } + }; + /** + * Registers a decoder with the stream, allowing for files compressed with + * the compression type provided to be expanded correctly + * @param decoder The decoder constructor + */ + Unzip.prototype.register = function (decoder) { + this.o[decoder.compression] = decoder; + }; + return Unzip; +}()); +exports.Unzip = Unzip; +var mt = typeof queueMicrotask == 'function' ? queueMicrotask : typeof setTimeout == 'function' ? setTimeout : function (fn) { fn(); }; +function unzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + var term = []; + var tAll = function () { + for (var i = 0; i < term.length; ++i) + term[i](); + }; + var files = {}; + var cbd = function (a, b) { + mt(function () { cb(a, b); }); + }; + mt(function () { cbd = cb; }); + var e = data.length - 22; + for (; b4(data, e) != 0x6054B50; --e) { + if (!e || data.length - e > 65558) { + cbd(err(13, 0, 1), null); + return tAll; + } + } + ; + var lft = b2(data, e + 8); + if (lft) { + var c = lft; + var o = b4(data, e + 16); + var z = b4(data, e - 20) == 0x7064B50; + if (z) { + var ze = b4(data, e - 12); + z = b4(data, ze) == 0x6064B50; + if (z) { + c = lft = b4(data, ze + 32); + o = b4(data, ze + 48); + } + } + var fltr = opts && opts.filter; + var _loop_3 = function (i) { + var _a = zh(data, o, z), c_1 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off); + o = no; + var cbl = function (e, d) { + if (e) { + tAll(); + cbd(e, null); + } + else { + if (d) + files[fn] = d; + if (!--lft) + cbd(null, files); + } + }; + if (!fltr || fltr({ + name: fn, + size: sc, + originalSize: su, + compression: c_1 + })) { + if (!c_1) + cbl(null, slc(data, b, b + sc)); + else if (c_1 == 8) { + var infl = data.subarray(b, b + sc); + // Synchronously decompress under 512KB, or barely-compressed data + if (su < 524288 || sc > 0.8 * su) { + try { + cbl(null, inflateSync(infl, { out: new u8(su) })); + } + catch (e) { + cbl(e, null); + } + } + else + term.push(inflate(infl, { size: su }, cbl)); + } + else + cbl(err(14, 'unknown compression type ' + c_1, 1), null); + } + else + cbl(null, null); + }; + for (var i = 0; i < c; ++i) { + _loop_3(i); + } + } + else + cbd(null, {}); + return tAll; +} +/** + * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better + * performance with more than one file. + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @returns The decompressed files + */ +function unzipSync(data, opts) { + var files = {}; + var e = data.length - 22; + for (; b4(data, e) != 0x6054B50; --e) { + if (!e || data.length - e > 65558) + err(13); + } + ; + var c = b2(data, e + 8); + if (!c) + return {}; + var o = b4(data, e + 16); + var z = b4(data, e - 20) == 0x7064B50; + if (z) { + var ze = b4(data, e - 12); + z = b4(data, ze) == 0x6064B50; + if (z) { + c = b4(data, ze + 32); + o = b4(data, ze + 48); + } + } + var fltr = opts && opts.filter; + for (var i = 0; i < c; ++i) { + var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off); + o = no; + if (!fltr || fltr({ + name: fn, + size: sc, + originalSize: su, + compression: c_2 + })) { + if (!c_2) + files[fn] = slc(data, b, b + sc); + else if (c_2 == 8) + files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) }); + else + err(14, 'unknown compression type ' + c_2); + } + } + return files; +} diff --git a/tools/ui/node_modules/fflate/lib/browser.d.cts b/tools/ui/node_modules/fflate/lib/browser.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..d430faf2b555c978d66c89f46155b72c2c45a971 --- /dev/null +++ b/tools/ui/node_modules/fflate/lib/browser.d.cts @@ -0,0 +1,1539 @@ +/** + * Codes for errors generated within this library + */ +export declare const FlateErrorCode: { + readonly UnexpectedEOF: 0; + readonly InvalidBlockType: 1; + readonly InvalidLengthLiteral: 2; + readonly InvalidDistance: 3; + readonly StreamFinished: 4; + readonly NoStreamHandler: 5; + readonly InvalidHeader: 6; + readonly NoCallback: 7; + readonly InvalidUTF8: 8; + readonly ExtraFieldTooLong: 9; + readonly InvalidDate: 10; + readonly FilenameTooLong: 11; + readonly StreamFinishing: 12; + readonly InvalidZipData: 13; + readonly UnknownCompressionMethod: 14; +}; +/** + * An error generated within this library + */ +export interface FlateError extends Error { + /** + * The code associated with this error + */ + code: number; +} +/** + * Options for decompressing a DEFLATE stream + */ +export interface InflateStreamOptions { + /** + * The dictionary used to compress the original data. If no dictionary was used during compression, this option has no effect. + * + * Supplying the wrong dictionary during decompression usually yields corrupt output or causes an invalid distance error. + */ + dictionary?: Uint8Array; +} +/** + * Options for decompressing DEFLATE data + */ +export interface InflateOptions extends InflateStreamOptions { + /** + * The buffer into which to write the decompressed data. Saves memory if you know the decompressed size in advance. + * + * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit. + */ + out?: Uint8Array; +} +/** + * Options for decompressing a GZIP stream + */ +export interface GunzipStreamOptions extends InflateStreamOptions { +} +/** + * Options for decompressing GZIP data + */ +export interface GunzipOptions extends InflateStreamOptions { + /** + * The buffer into which to write the decompressed data. GZIP already encodes the output size, so providing this doesn't save memory. + * + * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit. + */ + out?: Uint8Array; +} +/** + * Options for decompressing a Zlib stream + */ +export interface UnzlibStreamOptions extends InflateStreamOptions { +} +/** + * Options for decompressing Zlib data + */ +export interface UnzlibOptions extends InflateOptions { +} +/** + * Options for compressing data into a DEFLATE format + */ +export interface DeflateOptions { + /** + * The level of compression to use, ranging from 0-9. + * + * 0 will store the data without compression. + * 1 is fastest but compresses the worst, 9 is slowest but compresses the best. + * The default level is 6. + * + * Typically, binary data benefits much more from higher values than text data. + * In both cases, higher values usually take disproportionately longer than the reduction in final size that results. + * + * For example, a 1 MB text file could: + * - become 1.01 MB with level 0 in 1ms + * - become 400 kB with level 1 in 10ms + * - become 320 kB with level 9 in 100ms + */ + level?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + /** + * The memory level to use, ranging from 0-12. Increasing this increases speed and compression ratio at the cost of memory. + * + * Note that this is exponential: while level 0 uses 8 kB, level 4 uses 128 kB, level 8 uses 2 MB, and level 12 uses 32 MB. + * It is recommended not to lower the value below 4, since that tends to hurt performance. + * In addition, values above 8 tend to help very little on most data and can even hurt performance. + * + * The default value is automatically determined based on the size of the input data. + */ + mem?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12; + /** + * A buffer containing common byte sequences in the input data that can be used to significantly improve compression ratios. + * + * Dictionaries should be 32kB or smaller and include strings or byte sequences likely to appear in the input. + * The decompressor must supply the same dictionary as the compressor to extract the original data. + * + * Dictionaries only improve aggregate compression ratio when reused across multiple small inputs. They should typically not be used otherwise. + * + * Avoid using dictionaries with GZIP and ZIP to maximize software compatibility. + */ + dictionary?: Uint8Array; +} +/** + * Options for compressing data into a GZIP format + */ +export interface GzipOptions extends DeflateOptions { + /** + * When the file was last modified. Defaults to the current time. + * Set this to 0 to avoid revealing a modification date entirely. + */ + mtime?: Date | string | number; + /** + * The filename of the data. If the `gunzip` command is used to decompress the data, it will output a file + * with this name instead of the name of the compressed file. + */ + filename?: string; +} +/** + * Options for compressing data into a Zlib format + */ +export interface ZlibOptions extends DeflateOptions { +} +/** + * Handler for data (de)compression streams + * @param data The data output from the stream processor + * @param final Whether this is the final block + */ +export type FlateStreamHandler = (data: Uint8Array, final: boolean) => void; +/** + * Handler for asynchronous data (de)compression streams + * @param err Any error that occurred + * @param data The data output from the stream processor + * @param final Whether this is the final block + */ +export type AsyncFlateStreamHandler = (err: FlateError | null, data: Uint8Array, final: boolean) => void; +/** + * Handler for the asynchronous completion of (de)compression for a data chunk + * @param size The number of bytes that were processed. This is measured in terms of the input + * (i.e. compressed bytes for decompression, uncompressed bytes for compression.) + */ +export type AsyncFlateDrainHandler = (size: number) => void; +/** + * Callback for asynchronous (de)compression methods + * @param err Any error that occurred + * @param data The resulting data. Only present if `err` is null + */ +export type FlateCallback = (err: FlateError | null, data: Uint8Array) => void; +interface AsyncOptions { + /** + * Whether or not to "consume" the source data. This will make the typed array/buffer you pass in + * unusable but will increase performance and reduce memory usage. + */ + consume?: boolean; +} +/** + * Options for compressing data asynchronously into a DEFLATE format + */ +export interface AsyncDeflateOptions extends DeflateOptions, AsyncOptions { +} +/** + * Options for decompressing DEFLATE data asynchronously + */ +export interface AsyncInflateOptions extends AsyncOptions, InflateStreamOptions { + /** + * The original size of the data. Currently, the asynchronous API disallows + * writing into a buffer you provide; the best you can do is provide the + * size in bytes and be given back a new typed array. + */ + size?: number; +} +/** + * Options for compressing data asynchronously into a GZIP format + */ +export interface AsyncGzipOptions extends GzipOptions, AsyncOptions { +} +/** + * Options for decompressing GZIP data asynchronously + */ +export interface AsyncGunzipOptions extends AsyncOptions, InflateStreamOptions { +} +/** + * Options for compressing data asynchronously into a Zlib format + */ +export interface AsyncZlibOptions extends ZlibOptions, AsyncOptions { +} +/** + * Options for decompressing Zlib data asynchronously + */ +export interface AsyncUnzlibOptions extends AsyncInflateOptions { +} +/** + * A terminable compression/decompression process + */ +export interface AsyncTerminable { + /** + * Terminates the worker thread immediately. The callback will not be called. + */ + (): void; +} +/** + * Streaming DEFLATE compression + */ +export declare class Deflate { + /** + * Creates a DEFLATE stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: DeflateOptions, cb?: FlateStreamHandler); + /** + * Creates a DEFLATE stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + private b; + private s; + private o; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + private p; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE compression + */ +export declare class AsyncDeflate { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous DEFLATE stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: DeflateOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous DEFLATE stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function deflate(data: Uint8Array, opts: AsyncDeflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param cb The function to be called upon compression completion + */ +export declare function deflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @returns The deflated version of the data + */ +export declare function deflateSync(data: Uint8Array, opts?: DeflateOptions): Uint8Array; +/** + * Streaming DEFLATE decompression + */ +export declare class Inflate { + private s; + private o; + private p; + private d; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a DEFLATE decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: InflateStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a DEFLATE decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + private e; + private c; + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the final chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE decompression + */ +export declare class AsyncInflate { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous DEFLATE decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: InflateStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous DEFLATE decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function inflate(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function inflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands DEFLATE data with no wrapper + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function inflateSync(data: Uint8Array): Uint8Array; +/** + * Expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function inflateSync(data: Uint8Array, opts?: InflateOptions): Uint8Array; +/** + * Streaming GZIP compression + */ +export declare class Gzip { + private c; + private l; + private v; + private o; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a GZIP stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: GzipOptions, cb?: FlateStreamHandler); + /** + * Creates a GZIP stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + private p; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming GZIP compression + */ +export declare class AsyncGzip { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous GZIP stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: GzipOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous GZIP stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function gzip(data: Uint8Array, opts: AsyncGzipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with GZIP + * @param data The data to compress + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @returns The gzipped version of the data + */ +export declare function gzipSync(data: Uint8Array, opts?: GzipOptions): Uint8Array; +/** + * Handler for new GZIP members in concatenated GZIP streams. Useful for building indices used to perform random-access reads on compressed files. + * @param offset The offset of the new member relative to the start of the stream + */ +export type GunzipMemberHandler = (offset: number) => void; +/** + * Streaming single or multi-member GZIP decompression + */ +export declare class Gunzip { + private v; + private r; + private o; + private p; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * The handler to call whenever a new GZIP member is found + */ + onmember?: GunzipMemberHandler; + /** + * Creates a GUNZIP stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: GunzipStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a GUNZIP stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming single or multi-member GZIP decompression + */ +export declare class AsyncGunzip { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * The handler to call whenever a new GZIP member is found + */ + onmember?: GunzipMemberHandler; + /** + * Creates an asynchronous GUNZIP stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: GunzipStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous GUNZIP stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands GZIP data + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gunzip(data: Uint8Array, opts: AsyncGunzipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands GZIP data + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gunzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands GZIP data + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function gunzipSync(data: Uint8Array): Uint8Array; +/** + * Expands GZIP data + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function gunzipSync(data: Uint8Array, opts?: GunzipOptions): Uint8Array; +/** + * Streaming Zlib compression + */ +export declare class Zlib { + private c; + private v; + private o; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a Zlib stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: ZlibOptions, cb?: FlateStreamHandler); + /** + * Creates a Zlib stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be zlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + private p; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming Zlib compression + */ +export declare class AsyncZlib { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous Zlib stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: ZlibOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous Zlib stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with Zlib + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + */ +export declare function zlib(data: Uint8Array, opts: AsyncZlibOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with Zlib + * @param data The data to compress + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compress data with Zlib + * @param data The data to compress + * @param opts The compression options + * @returns The zlib-compressed version of the data + */ +export declare function zlibSync(data: Uint8Array, opts?: ZlibOptions): Uint8Array; +/** + * Streaming Zlib decompression + */ +export declare class Unzlib { + private v; + private p; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a Zlib decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: UnzlibStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a Zlib decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be unzlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming Zlib decompression + */ +export declare class AsyncUnzlib { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous Zlib decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: UnzlibStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous Zlib decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be decompressed from Zlib + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands Zlib data + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function unzlib(data: Uint8Array, opts: AsyncUnzlibOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands Zlib data + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function unzlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands Zlib data + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function unzlibSync(data: Uint8Array): Uint8Array; +/** + * Expands Zlib data + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function unzlibSync(data: Uint8Array, opts?: UnzlibOptions): Uint8Array; +export { gzip as compress, AsyncGzip as AsyncCompress }; +export { gzipSync as compressSync, Gzip as Compress }; +/** + * Streaming GZIP, Zlib, or raw DEFLATE decompression + */ +export declare class Decompress { + private G; + private I; + private Z; + private o; + private s; + private p; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is decompressed + */ + constructor(opts: InflateStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a decompression stream + * @param cb The callback to call whenever data is decompressed + */ + constructor(cb?: FlateStreamHandler); + private i; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression + */ +export declare class AsyncDecompress { + private G; + private I; + private Z; + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is decompressed + */ + constructor(opts: InflateStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous decompression stream + * @param cb The callback to call whenever data is decompressed + */ + constructor(cb?: AsyncFlateStreamHandler); + private i; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function decompress(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function decompress(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function decompressSync(data: Uint8Array, opts?: InflateOptions): Uint8Array; +/** + * Attributes for files added to a ZIP archive object + */ +export interface ZipAttributes { + /** + * The operating system of origin for this file. The value is defined + * by PKZIP's APPNOTE.txt, section 4.4.2.2. For example, 0 (the default) + * is MS/DOS, 3 is Unix, 19 is macOS. + */ + os?: number; + /** + * The file's attributes. These are traditionally somewhat complicated + * and platform-dependent, so using them is scarcely necessary. However, + * here is a representation of what this is, bit by bit: + * + * `TTTTugtrwxrwxrwx0000000000ADVSHR` + * + * TTTT = file type (rarely useful) + * + * u = setuid, g = setgid, t = sticky + * + * rwx = user permissions, rwx = group permissions, rwx = other permissions + * + * 0000000000 = unused + * + * A = archive, D = directory, V = volume label, S = system file, H = hidden, R = read-only + * + * If you want to set the Unix permissions, for instance, just bit shift by 16, e.g. 0o644 << 16. + * Note that attributes usually only work in conjunction with the `os` setting: you must use + * `os` = 3 (Unix) if you want to set Unix permissions + */ + attrs?: number; + /** + * Extra metadata to add to the file. This field is defined by PKZIP's APPNOTE.txt, + * section 4.4.28. At most 65,535 bytes may be used in each ID. The ID must be an + * integer between 0 and 65,535, inclusive. + * + * This field is incredibly rare and almost never needed except for compliance with + * proprietary standards and software. + */ + extra?: Record; + /** + * The comment to attach to the file. This field is defined by PKZIP's APPNOTE.txt, + * section 4.4.26. The comment must be at most 65,535 bytes long UTF-8 encoded. This + * field is not read by consumer software. + */ + comment?: string; + /** + * When the file was last modified. Defaults to the current time. + */ + mtime?: GzipOptions['mtime']; +} +/** + * Options for creating a ZIP archive + */ +export interface ZipOptions extends DeflateOptions, ZipAttributes { +} +/** + * Options for expanding a ZIP archive + */ +export interface UnzipOptions { + /** + * A filter function to extract only certain files from a ZIP archive + */ + filter?: UnzipFileFilter; +} +/** + * Options for asynchronously creating a ZIP archive + */ +export interface AsyncZipOptions extends AsyncDeflateOptions, ZipAttributes { +} +/** + * Options for asynchronously expanding a ZIP archive + */ +export interface AsyncUnzipOptions extends UnzipOptions { +} +/** + * A file that can be used to create a ZIP archive + */ +export type ZippableFile = Uint8Array | Zippable | [Uint8Array | Zippable, ZipOptions]; +/** + * A file that can be used to asynchronously create a ZIP archive + */ +export type AsyncZippableFile = Uint8Array | AsyncZippable | [Uint8Array | AsyncZippable, AsyncZipOptions]; +/** + * The complete directory structure of a ZIPpable archive + */ +export interface Zippable { + [path: string]: ZippableFile; +} +/** + * The complete directory structure of an asynchronously ZIPpable archive + */ +export interface AsyncZippable { + [path: string]: AsyncZippableFile; +} +/** + * An unzipped archive. The full path of each file is used as the key, + * and the file is the value + */ +export interface Unzipped { + [path: string]: Uint8Array; +} +/** + * Handler for string generation streams + * @param data The string output from the stream processor + * @param final Whether this is the final block + */ +export type StringStreamHandler = (data: string, final: boolean) => void; +/** + * Callback for asynchronous ZIP decompression + * @param err Any error that occurred + * @param data The decompressed ZIP archive + */ +export type UnzipCallback = (err: FlateError | null, data: Unzipped) => void; +/** + * Handler for streaming ZIP decompression + * @param file The file that was found in the archive + */ +export type UnzipFileHandler = (file: UnzipFile) => void; +/** + * Streaming UTF-8 decoding + */ +export declare class DecodeUTF8 { + private p; + private t; + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is decoded + */ + constructor(cb?: StringStreamHandler); + /** + * Pushes a chunk to be decoded from UTF-8 binary + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * The handler to call whenever data is available + */ + ondata: StringStreamHandler; +} +/** + * Streaming UTF-8 encoding + */ +export declare class EncodeUTF8 { + private d; + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is encoded + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be encoded to UTF-8 + * @param chunk The string data to push + * @param final Whether this is the last chunk + */ + push(chunk: string, final?: boolean): void; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; +} +/** + * Converts a string into a Uint8Array for use with compression/decompression methods + * @param str The string to encode + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless decoding a binary string. + * @returns The string encoded in UTF-8/Latin-1 binary + */ +export declare function strToU8(str: string, latin1?: boolean): Uint8Array; +/** + * Converts a Uint8Array to a string + * @param dat The data to decode to string + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless encoding to binary string. + * @returns The original UTF-8/Latin-1 string + */ +export declare function strFromU8(dat: Uint8Array, latin1?: boolean): string; +/** + * A stream that can be used to create a file in a ZIP archive + */ +export interface ZipInputFile extends ZipAttributes { + /** + * The filename to associate with the data provided to this stream. If you + * want a file in a subdirectory, use forward slashes as a separator (e.g. + * `directory/filename.ext`). This will still work on Windows. + */ + filename: string; + /** + * The size of the file in bytes. This attribute may be invalid after + * the file is added to the ZIP archive; it must be correct only before the + * stream completes. + * + * If you don't want to have to compute this yourself, consider extending the + * ZipPassThrough class and overriding its process() method, or using one of + * ZipDeflate or AsyncZipDeflate. + */ + size: number; + /** + * A CRC of the original file contents. This attribute may be invalid after + * the file is added to the ZIP archive; it must be correct only before the + * stream completes. + * + * If you don't want to have to generate this yourself, consider extending the + * ZipPassThrough class and overriding its process() method, or using one of + * ZipDeflate or AsyncZipDeflate. + */ + crc: number; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA + */ + compression: number; + /** + * Bits 1 and 2 of the general purpose bit flag, specified in PKZIP's + * APPNOTE.txt, section 4.4.4. Should be between 0 and 3. This is unlikely + * to be necessary. + */ + flag?: number; + /** + * The handler to be called when data is added. After passing this stream to + * the ZIP file object, this handler will always be defined. To call it: + * + * `stream.ondata(error, chunk, final)` + * + * error = any error that occurred (null if there was no error) + * + * chunk = a Uint8Array of the data that was added (null if there was an + * error) + * + * final = boolean, whether this is the final chunk in the stream + */ + ondata?: AsyncFlateStreamHandler; + /** + * A method called when the stream is no longer needed, for clean-up + * purposes. This will not always be called after the stream completes, + * so you may wish to call this.terminate() after the final chunk is + * processed if you have clean-up logic. + */ + terminate?: AsyncTerminable; +} +/** + * A pass-through stream to keep data uncompressed in a ZIP archive. + */ +export declare class ZipPassThrough implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private c; + /** + * Creates a pass-through stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + */ + constructor(filename: string); + /** + * Processes a chunk and pushes to the output stream. You can override this + * method in a subclass for custom behavior, but by default this passes + * the data through. You must call this.ondata(err, chunk, final) at some + * point in this method. + * @param chunk The chunk to process + * @param final Whether this is the last chunk + */ + protected process(chunk: Uint8Array, final: boolean): void; + /** + * Pushes a chunk to be added. If you are subclassing this with a custom + * compression algorithm, note that you must push data from the source + * file only, pre-compression. + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate + * for better performance + */ +export declare class ZipDeflate implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + flag: 0 | 1 | 2 | 3; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private d; + /** + * Creates a DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + constructor(filename: string, opts?: DeflateOptions); + private process; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE compression for ZIP archives + */ +export declare class AsyncZipDeflate implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + flag: 0 | 1 | 2 | 3; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private d; + terminate: AsyncTerminable; + /** + * Creates an asynchronous DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + constructor(filename: string, opts?: DeflateOptions); + private process; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * A zippable archive to which files can incrementally be added + */ +export declare class Zip { + private u; + private d; + /** + * Creates an empty ZIP archive to which files can be added + * @param cb The callback to call whenever data for the generated ZIP archive + * is available + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Adds a file to the ZIP archive + * @param file The file stream to add + */ + add(file: ZipInputFile): void; + /** + * Ends the process of adding files and prepares to emit the final chunks. + * This *must* be called after adding all desired files for the resulting + * ZIP file to work properly. + */ + end(): void; + private e; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to add() will fail. + */ + terminate(): void; + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; +} +/** + * Asynchronously creates a ZIP file + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @param cb The callback to call with the generated ZIP archive + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zip(data: AsyncZippable, opts: AsyncZipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously creates a ZIP file + * @param data The directory structure for the ZIP archive + * @param cb The callback to call with the generated ZIP archive + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zip(data: AsyncZippable, cb: FlateCallback): AsyncTerminable; +/** + * Synchronously creates a ZIP file. Prefer using `zip` for better performance + * with more than one file. + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @returns The generated ZIP archive + */ +export declare function zipSync(data: Zippable, opts?: ZipOptions): Uint8Array; +/** + * A decoder for files in ZIP streams + */ +export interface UnzipDecoder { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * Pushes a chunk to be decompressed + * @param chunk The data in this chunk. Do not consume (detach) this buffer. + * @param final Whether this is the last chunk in the data stream + */ + push(chunk: Uint8Array, final: boolean): void; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to push() should silently fail. + */ + terminate?: AsyncTerminable; +} +/** + * A constructor for a decoder for unzip streams + */ +export interface UnzipDecoderConstructor { + /** + * Creates an instance of the decoder + * @param filename The name of the file + * @param size The compressed size of the file + * @param originalSize The original size of the file + */ + new (filename: string, size?: number, originalSize?: number): UnzipDecoder; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA + */ + compression: number; +} +/** + * Information about a file to be extracted from a ZIP archive + */ +export interface UnzipFileInfo { + /** + * The name of the file + */ + name: string; + /** + * The compressed size of the file + */ + size: number; + /** + * The original size of the file + */ + originalSize: number; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA. If the filter function returns true + * but this value is not 8, the unzip function will throw. + */ + compression: number; +} +/** + * A filter for files to be extracted during the unzipping process + * @param file The info for the current file being processed + * @returns Whether or not to extract the current file + */ +export type UnzipFileFilter = (file: UnzipFileInfo) => boolean; +/** + * Streaming file extraction from ZIP archives + */ +export interface UnzipFile { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The name of the file + */ + name: string; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA. If start() is called but there is no + * decompression stream available for this method, start() will throw. + */ + compression: number; + /** + * The compressed size of the file. Will not be present for archives created + * in a streaming fashion. + */ + size?: number; + /** + * The original size of the file. Will not be present for archives created + * in a streaming fashion. + */ + originalSize?: number; + /** + * Starts reading from the stream. Calling this function will always enable + * this stream, but ocassionally the stream will be enabled even without + * this being called. + */ + start(): void; + /** + * A method to terminate any internal workers used by the stream. ondata + * will not be called any further. + */ + terminate: AsyncTerminable; +} +/** + * Streaming pass-through decompression for ZIP archives + */ +export declare class UnzipPassThrough implements UnzipDecoder { + static compression: number; + ondata: AsyncFlateStreamHandler; + push(chunk: Uint8Array, final: boolean): void; +} +/** + * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for + * better performance. + */ +export declare class UnzipInflate implements UnzipDecoder { + static compression: number; + private i; + ondata: AsyncFlateStreamHandler; + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + constructor(); + push(chunk: Uint8Array, final: boolean): void; +} +/** + * Asynchronous streaming DEFLATE decompression for ZIP archives + */ +export declare class AsyncUnzipInflate implements UnzipDecoder { + static compression: number; + private i; + ondata: AsyncFlateStreamHandler; + terminate: AsyncTerminable; + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + constructor(_: string, sz?: number); + push(chunk: Uint8Array, final: boolean): void; +} +/** + * A ZIP archive decompression stream that emits files as they are discovered + */ +export declare class Unzip { + private d; + private c; + private p; + private k; + private o; + /** + * Creates a ZIP decompression stream + * @param cb The callback to call whenever a file in the ZIP archive is found + */ + constructor(cb?: UnzipFileHandler); + /** + * Pushes a chunk to be unzipped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Registers a decoder with the stream, allowing for files compressed with + * the compression type provided to be expanded correctly + * @param decoder The decoder constructor + */ + register(decoder: UnzipDecoderConstructor): void; + /** + * The handler to call whenever a file is discovered + */ + onfile: UnzipFileHandler; +} +/** + * Asynchronously decompresses a ZIP archive + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @param cb The callback to call with the decompressed files + * @returns A function that can be used to immediately terminate the unzipping + */ +export declare function unzip(data: Uint8Array, opts: AsyncUnzipOptions, cb: UnzipCallback): AsyncTerminable; +/** + * Asynchronously decompresses a ZIP archive + * @param data The raw compressed ZIP file + * @param cb The callback to call with the decompressed files + * @returns A function that can be used to immediately terminate the unzipping + */ +export declare function unzip(data: Uint8Array, cb: UnzipCallback): AsyncTerminable; +/** + * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better + * performance with more than one file. + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @returns The decompressed files + */ +export declare function unzipSync(data: Uint8Array, opts?: UnzipOptions): Unzipped; diff --git a/tools/ui/node_modules/fflate/lib/index.cjs b/tools/ui/node_modules/fflate/lib/index.cjs new file mode 100644 index 0000000000000000000000000000000000000000..ea4da56d93b2462ca17e4220840416d561b4a645 --- /dev/null +++ b/tools/ui/node_modules/fflate/lib/index.cjs @@ -0,0 +1,2697 @@ +"use strict"; +// DEFLATE is a complex format; to read this code, you should probably check the RFC first: +// https://tools.ietf.org/html/rfc1951 +// You may also wish to take a look at the guide I made about this program: +// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad +exports.deflate = deflate; +exports.deflateSync = deflateSync; +exports.inflate = inflate; +exports.inflateSync = inflateSync; +exports.gzip = gzip; +exports.compress = gzip; +exports.gzipSync = gzipSync; +exports.compressSync = gzipSync; +exports.gunzip = gunzip; +exports.gunzipSync = gunzipSync; +exports.zlib = zlib; +exports.zlibSync = zlibSync; +exports.unzlib = unzlib; +exports.unzlibSync = unzlibSync; +exports.gzip = gzip; +exports.compress = gzip; +exports.decompress = decompress; +exports.decompressSync = decompressSync; +exports.strToU8 = strToU8; +exports.strFromU8 = strFromU8; +exports.zip = zip; +exports.zipSync = zipSync; +exports.unzip = unzip; +exports.unzipSync = unzipSync; +// Some of the following code is similar to that of UZIP.js: +// https://github.com/photopea/UZIP.js +// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size. +// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint +// is better for memory in most engines (I *think*). +var node_worker_1 = require("./node-worker.cjs"); +// aliases for shorter compressed code (most minifers don't do this) +var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array; +// fixed length extra bits +var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]); +// fixed distance extra bits +var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]); +// code length index map +var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]); +// get base, reverse index map from extra bits +var freb = function (eb, start) { + var b = new u16(31); + for (var i = 0; i < 31; ++i) { + b[i] = start += 1 << eb[i - 1]; + } + // numbers here are at max 18 bits + var r = new i32(b[30]); + for (var i = 1; i < 30; ++i) { + for (var j = b[i]; j < b[i + 1]; ++j) { + r[j] = ((j - b[i]) << 5) | i; + } + } + return { b: b, r: r }; +}; +var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r; +// we can ignore the fact that the other numbers are wrong; they never happen anyway +fl[28] = 258, revfl[258] = 28; +var _b = freb(fdeb, 0), fd = _b.b, revfd = _b.r; +// map of value to reverse (assuming 16 bits) +var rev = new u16(32768); +for (var i = 0; i < 32768; ++i) { + // reverse table algorithm from SO + var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1); + x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2); + x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4); + rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1; +} +// create huffman tree from u8 "map": index -> code length for code index +// mb (max bits) must be at most 15 +// TODO: optimize/split up? +var hMap = (function (cd, mb, r) { + var s = cd.length; + // index + var i = 0; + // u16 "map": index -> # of codes with bit length = index + var l = new u16(mb); + // length of cd must be 288 (total # of codes) + for (; i < s; ++i) { + if (cd[i]) + ++l[cd[i] - 1]; + } + // u16 "map": index -> minimum code for bit length = index + var le = new u16(mb); + for (i = 1; i < mb; ++i) { + le[i] = (le[i - 1] + l[i - 1]) << 1; + } + var co; + if (r) { + // u16 "map": index -> number of actual bits, symbol for code + co = new u16(1 << mb); + // bits to remove for reverser + var rvb = 15 - mb; + for (i = 0; i < s; ++i) { + // ignore 0 lengths + if (cd[i]) { + // num encoding both symbol and bits read + var sv = (i << 4) | cd[i]; + // free bits + var r_1 = mb - cd[i]; + // start value + var v = le[cd[i] - 1]++ << r_1; + // m is end value + for (var m = v | ((1 << r_1) - 1); v <= m; ++v) { + // every 16 bit value starting with the code yields the same result + co[rev[v] >> rvb] = sv; + } + } + } + } + else { + co = new u16(s); + for (i = 0; i < s; ++i) { + if (cd[i]) { + co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]); + } + } + } + return co; +}); +// fixed length tree +var flt = new u8(288); +for (var i = 0; i < 144; ++i) + flt[i] = 8; +for (var i = 144; i < 256; ++i) + flt[i] = 9; +for (var i = 256; i < 280; ++i) + flt[i] = 7; +for (var i = 280; i < 288; ++i) + flt[i] = 8; +// fixed distance tree +var fdt = new u8(32); +for (var i = 0; i < 32; ++i) + fdt[i] = 5; +// fixed length map +var flm = /*#__PURE__*/ hMap(flt, 9, 0), flrm = /*#__PURE__*/ hMap(flt, 9, 1); +// fixed distance map +var fdm = /*#__PURE__*/ hMap(fdt, 5, 0), fdrm = /*#__PURE__*/ hMap(fdt, 5, 1); +// find max of array +var max = function (a) { + var m = a[0]; + for (var i = 1; i < a.length; ++i) { + if (a[i] > m) + m = a[i]; + } + return m; +}; +// read d, starting at bit p and mask with m +var bits = function (d, p, m) { + var o = (p / 8) | 0; + return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m; +}; +// read d, starting at bit p continuing for at least 16 bits +var bits16 = function (d, p) { + var o = (p / 8) | 0; + return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7)); +}; +// get end of byte +var shft = function (p) { return ((p + 7) / 8) | 0; }; +// typed array slice - allows garbage collector to free original reference, +// while being more compatible than .slice +var slc = function (v, s, e) { + if (s == null || s < 0) + s = 0; + if (e == null || e > v.length) + e = v.length; + // can't use .constructor in case user-supplied + return new u8(v.subarray(s, e)); +}; +/** + * Codes for errors generated within this library + */ +exports.FlateErrorCode = { + UnexpectedEOF: 0, + InvalidBlockType: 1, + InvalidLengthLiteral: 2, + InvalidDistance: 3, + StreamFinished: 4, + NoStreamHandler: 5, + InvalidHeader: 6, + NoCallback: 7, + InvalidUTF8: 8, + ExtraFieldTooLong: 9, + InvalidDate: 10, + FilenameTooLong: 11, + StreamFinishing: 12, + InvalidZipData: 13, + UnknownCompressionMethod: 14 +}; +// error codes +var ec = [ + 'unexpected EOF', + 'invalid block type', + 'invalid length/literal', + 'invalid distance', + 'stream finished', + 'no stream handler', + , // determined by compression function + 'no callback', + 'invalid UTF-8 data', + 'extra field too long', + 'date not in range 1980-2099', + 'filename too long', + 'stream finishing', + 'invalid zip data' + // determined by unknown compression method +]; +; +var err = function (ind, msg, nt) { + var e = new Error(msg || ec[ind]); + e.code = ind; + if (Error.captureStackTrace) + Error.captureStackTrace(e, err); + if (!nt) + throw e; + return e; +}; +// expands raw DEFLATE data +var inflt = function (dat, st, buf, dict) { + // source length dict length + var sl = dat.length, dl = dict ? dict.length : 0; + if (!sl || st.f && !st.l) + return buf || new u8(0); + var noBuf = !buf; + // have to estimate size + var resize = noBuf || st.i != 2; + // no state + var noSt = st.i; + // Assumes roughly 33% compression ratio average + if (noBuf) + buf = new u8(sl * 3); + // ensure buffer can fit at least l elements + var cbuf = function (l) { + var bl = buf.length; + // need to increase size to fit + if (l > bl) { + // Double or set to necessary, whichever is greater + var nbuf = new u8(Math.max(bl * 2, l)); + nbuf.set(buf); + buf = nbuf; + } + }; + // last chunk bitpos bytes + var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n; + // total bits + var tbts = sl * 8; + do { + if (!lm) { + // BFINAL - this is only 1 when last chunk is next + final = bits(dat, pos, 1); + // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman + var type = bits(dat, pos + 1, 3); + pos += 3; + if (!type) { + // go to end of byte boundary + var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l; + if (t > sl) { + if (noSt) + err(0); + break; + } + // ensure size + if (resize) + cbuf(bt + l); + // Copy over uncompressed data + buf.set(dat.subarray(s, t), bt); + // Get new bitpos, update byte count + st.b = bt += l, st.p = pos = t * 8, st.f = final; + continue; + } + else if (type == 1) + lm = flrm, dm = fdrm, lbt = 9, dbt = 5; + else if (type == 2) { + // literal lengths + var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4; + var tl = hLit + bits(dat, pos + 5, 31) + 1; + pos += 14; + // length+distance tree + var ldt = new u8(tl); + // code length tree + var clt = new u8(19); + for (var i = 0; i < hcLen; ++i) { + // use index map to get real code + clt[clim[i]] = bits(dat, pos + i * 3, 7); + } + pos += hcLen * 3; + // code lengths bits + var clb = max(clt), clbmsk = (1 << clb) - 1; + // code lengths map + var clm = hMap(clt, clb, 1); + for (var i = 0; i < tl;) { + var r = clm[bits(dat, pos, clbmsk)]; + // bits read + pos += r & 15; + // symbol + var s = r >> 4; + // code length to copy + if (s < 16) { + ldt[i++] = s; + } + else { + // copy count + var c = 0, n = 0; + if (s == 16) + n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1]; + else if (s == 17) + n = 3 + bits(dat, pos, 7), pos += 3; + else if (s == 18) + n = 11 + bits(dat, pos, 127), pos += 7; + while (n--) + ldt[i++] = c; + } + } + // length tree distance tree + var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit); + // max length bits + lbt = max(lt); + // max dist bits + dbt = max(dt); + lm = hMap(lt, lbt, 1); + dm = hMap(dt, dbt, 1); + } + else + err(1); + if (pos > tbts) { + if (noSt) + err(0); + break; + } + } + // Make sure the buffer can hold this + the largest possible addition + // Maximum chunk size (practically, theoretically infinite) is 2^17 + if (resize) + cbuf(bt + 131072); + var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1; + var lpos = pos; + for (;; lpos = pos) { + // bits read, code + var c = lm[bits16(dat, pos) & lms], sym = c >> 4; + pos += c & 15; + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (!c) + err(2); + if (sym < 256) + buf[bt++] = sym; + else if (sym == 256) { + lpos = pos, lm = null; + break; + } + else { + var add = sym - 254; + // no extra bits needed if less + if (sym > 264) { + // index + var i = sym - 257, b = fleb[i]; + add = bits(dat, pos, (1 << b) - 1) + fl[i]; + pos += b; + } + // dist + var d = dm[bits16(dat, pos) & dms], dsym = d >> 4; + if (!d) + err(3); + pos += d & 15; + var dt = fd[dsym]; + if (dsym > 3) { + var b = fdeb[dsym]; + dt += bits16(dat, pos) & (1 << b) - 1, pos += b; + } + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (resize) + cbuf(bt + 131072); + var end = bt + add; + if (bt < dt) { + var shift = dl - dt, dend = Math.min(dt, end); + if (shift + bt < 0) + err(3); + for (; bt < dend; ++bt) + buf[bt] = dict[shift + bt]; + } + for (; bt < end; ++bt) + buf[bt] = buf[bt - dt]; + } + } + st.l = lm, st.p = lpos, st.b = bt, st.f = final; + if (lm) + final = 1, st.m = lbt, st.d = dm, st.n = dbt; + } while (!final); + // don't reallocate for streams or user buffers + return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt); +}; +// starting at p, write the minimum number of bits that can hold v to d +var wbits = function (d, p, v) { + v <<= p & 7; + var o = (p / 8) | 0; + d[o] |= v; + d[o + 1] |= v >> 8; +}; +// starting at p, write the minimum number of bits (>8) that can hold v to d +var wbits16 = function (d, p, v) { + v <<= p & 7; + var o = (p / 8) | 0; + d[o] |= v; + d[o + 1] |= v >> 8; + d[o + 2] |= v >> 16; +}; +// creates code lengths from a frequency table +var hTree = function (d, mb) { + // Need extra info to make a tree + var t = []; + for (var i = 0; i < d.length; ++i) { + if (d[i]) + t.push({ s: i, f: d[i] }); + } + var s = t.length; + var t2 = t.slice(); + if (!s) + return { t: et, l: 0 }; + if (s == 1) { + var v = new u8(t[0].s + 1); + v[t[0].s] = 1; + return { t: v, l: 1 }; + } + t.sort(function (a, b) { return a.f - b.f; }); + // after i2 reaches last ind, will be stopped + // freq must be greater than largest possible number of symbols + t.push({ s: -1, f: 25001 }); + var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2; + t[0] = { s: -1, f: l.f + r.f, l: l, r: r }; + // efficient algorithm from UZIP.js + // i0 is lookbehind, i2 is lookahead - after processing two low-freq + // symbols that combined have high freq, will start processing i2 (high-freq, + // non-composite) symbols instead + // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/ + while (i1 != s - 1) { + l = t[t[i0].f < t[i2].f ? i0++ : i2++]; + r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++]; + t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r }; + } + var maxSym = t2[0].s; + for (var i = 1; i < s; ++i) { + if (t2[i].s > maxSym) + maxSym = t2[i].s; + } + // code lengths + var tr = new u16(maxSym + 1); + // max bits in tree + var mbt = ln(t[i1 - 1], tr, 0); + if (mbt > mb) { + // more algorithms from UZIP.js + // TODO: find out how this code works (debt) + // ind debt + var i = 0, dt = 0; + // left cost + var lft = mbt - mb, cst = 1 << lft; + t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; }); + for (; i < s; ++i) { + var i2_1 = t2[i].s; + if (tr[i2_1] > mb) { + dt += cst - (1 << (mbt - tr[i2_1])); + tr[i2_1] = mb; + } + else + break; + } + dt >>= lft; + while (dt > 0) { + var i2_2 = t2[i].s; + if (tr[i2_2] < mb) + dt -= 1 << (mb - tr[i2_2]++ - 1); + else + ++i; + } + for (; i >= 0 && dt; --i) { + var i2_3 = t2[i].s; + if (tr[i2_3] == mb) { + --tr[i2_3]; + ++dt; + } + } + mbt = mb; + } + return { t: new u8(tr), l: mbt }; +}; +// get the max length and assign length codes +var ln = function (n, l, d) { + return n.s == -1 + ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) + : (l[n.s] = d); +}; +// length codes generation +var lc = function (c) { + var s = c.length; + // Note that the semicolon was intentional + while (s && !c[--s]) + ; + var cl = new u16(++s); + // ind num streak + var cli = 0, cln = c[0], cls = 1; + var w = function (v) { cl[cli++] = v; }; + for (var i = 1; i <= s; ++i) { + if (c[i] == cln && i != s) + ++cls; + else { + if (!cln && cls > 2) { + for (; cls > 138; cls -= 138) + w(32754); + if (cls > 2) { + w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305); + cls = 0; + } + } + else if (cls > 3) { + w(cln), --cls; + for (; cls > 6; cls -= 6) + w(8304); + if (cls > 2) + w(((cls - 3) << 5) | 8208), cls = 0; + } + while (cls--) + w(cln); + cls = 1; + cln = c[i]; + } + } + return { c: cl.subarray(0, cli), n: s }; +}; +// calculate the length of output from tree, code lengths +var clen = function (cf, cl) { + var l = 0; + for (var i = 0; i < cl.length; ++i) + l += cf[i] * cl[i]; + return l; +}; +// writes a fixed block +// returns the new bit pos +var wfblk = function (out, pos, dat) { + // no need to write 00 as type: TypedArray defaults to 0 + var s = dat.length; + var o = shft(pos + 2); + out[o] = s & 255; + out[o + 1] = s >> 8; + out[o + 2] = out[o] ^ 255; + out[o + 3] = out[o + 1] ^ 255; + for (var i = 0; i < s; ++i) + out[o + i + 4] = dat[i]; + return (o + 4 + s) * 8; +}; +// writes a block +var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) { + wbits(out, p++, final); + ++lf[256]; + var _a = hTree(lf, 15), dlt = _a.t, mlb = _a.l; + var _b = hTree(df, 15), ddt = _b.t, mdb = _b.l; + var _c = lc(dlt), lclt = _c.c, nlc = _c.n; + var _d = lc(ddt), lcdt = _d.c, ndc = _d.n; + var lcfreq = new u16(19); + for (var i = 0; i < lclt.length; ++i) + ++lcfreq[lclt[i] & 31]; + for (var i = 0; i < lcdt.length; ++i) + ++lcfreq[lcdt[i] & 31]; + var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l; + var nlcc = 19; + for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc) + ; + var flen = (bl + 5) << 3; + var ftlen = clen(lf, flt) + clen(df, fdt) + eb; + var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]; + if (bs >= 0 && flen <= ftlen && flen <= dtlen) + return wfblk(out, p, dat.subarray(bs, bs + bl)); + var lm, ll, dm, dl; + wbits(out, p, 1 + (dtlen < ftlen)), p += 2; + if (dtlen < ftlen) { + lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt; + var llm = hMap(lct, mlcb, 0); + wbits(out, p, nlc - 257); + wbits(out, p + 5, ndc - 1); + wbits(out, p + 10, nlcc - 4); + p += 14; + for (var i = 0; i < nlcc; ++i) + wbits(out, p + 3 * i, lct[clim[i]]); + p += 3 * nlcc; + var lcts = [lclt, lcdt]; + for (var it = 0; it < 2; ++it) { + var clct = lcts[it]; + for (var i = 0; i < clct.length; ++i) { + var len = clct[i] & 31; + wbits(out, p, llm[len]), p += lct[len]; + if (len > 15) + wbits(out, p, (clct[i] >> 5) & 127), p += clct[i] >> 12; + } + } + } + else { + lm = flm, ll = flt, dm = fdm, dl = fdt; + } + for (var i = 0; i < li; ++i) { + var sym = syms[i]; + if (sym > 255) { + var len = (sym >> 18) & 31; + wbits16(out, p, lm[len + 257]), p += ll[len + 257]; + if (len > 7) + wbits(out, p, (sym >> 23) & 31), p += fleb[len]; + var dst = sym & 31; + wbits16(out, p, dm[dst]), p += dl[dst]; + if (dst > 3) + wbits16(out, p, (sym >> 5) & 8191), p += fdeb[dst]; + } + else { + wbits16(out, p, lm[sym]), p += ll[sym]; + } + } + wbits16(out, p, lm[256]); + return p + ll[256]; +}; +// deflate options (nice << 13) | chain +var deo = /*#__PURE__*/ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]); +// empty +var et = /*#__PURE__*/ new u8(0); +// compresses data into a raw DEFLATE buffer +var dflt = function (dat, lvl, plvl, pre, post, st) { + var s = st.z || dat.length; + var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post); + // writing to this writes to the output buffer + var w = o.subarray(pre, o.length - post); + var lst = st.l; + var pos = (st.r || 0) & 7; + if (lvl) { + if (pos) + w[0] = st.r >> 3; + var opt = deo[lvl - 1]; + var n = opt >> 13, c = opt & 8191; + var msk_1 = (1 << plvl) - 1; + // prev 2-byte val map curr 2-byte val map + var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1); + var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1; + var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; }; + // 24576 is an arbitrary number of maximum symbols per block + // 424 buffer for last block + var syms = new i32(25000); + // length/literal freq distance freq + var lf = new u16(288), df = new u16(32); + // l/lcnt exbits index l/lind waitdx blkpos + var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0; + for (; i + 2 < s; ++i) { + // hash value + var hv = hsh(i); + // index mod 32768 previous index mod + var imod = i & 32767, pimod = head[hv]; + prev[imod] = pimod; + head[hv] = imod; + // We always should modify head and prev, but only add symbols if + // this data is not yet processed ("wait" for wait index) + if (wi <= i) { + // bytes remaining + var rem = s - i; + if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) { + pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos); + li = lc_1 = eb = 0, bs = i; + for (var j = 0; j < 286; ++j) + lf[j] = 0; + for (var j = 0; j < 30; ++j) + df[j] = 0; + } + // len dist chain + var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767; + if (rem > 2 && hv == hsh(i - dif)) { + var maxn = Math.min(n, rem) - 1; + var maxd = Math.min(32767, i); + // max possible length + // not capped at dif because decompressors implement "rolling" index population + var ml = Math.min(258, rem); + while (dif <= maxd && --ch_1 && imod != pimod) { + if (dat[i + l] == dat[i + l - dif]) { + var nl = 0; + for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl) + ; + if (nl > l) { + l = nl, d = dif; + // break out early when we reach "nice" (we are satisfied enough) + if (nl > maxn) + break; + // now, find the rarest 2-byte sequence within this + // length of literals and search for that instead. + // Much faster than just using the start + var mmd = Math.min(dif, nl - 2); + var md = 0; + for (var j = 0; j < mmd; ++j) { + var ti = i - dif + j & 32767; + var pti = prev[ti]; + var cd = ti - pti & 32767; + if (cd > md) + md = cd, pimod = ti; + } + } + } + // check the previous match + imod = pimod, pimod = prev[imod]; + dif += imod - pimod & 32767; + } + } + // d will be nonzero only when a match was found + if (d) { + // store both dist and len data in one int32 + // Make sure this is recognized as a len/dist with 28th bit (2^28) + syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d]; + var lin = revfl[l] & 31, din = revfd[d] & 31; + eb += fleb[lin] + fdeb[din]; + ++lf[257 + lin]; + ++df[din]; + wi = i + l; + ++lc_1; + } + else { + syms[li++] = dat[i]; + ++lf[dat[i]]; + } + } + } + for (i = Math.max(i, wi); i < s; ++i) { + syms[li++] = dat[i]; + ++lf[dat[i]]; + } + pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos); + if (!lst) { + st.r = (pos & 7) | w[(pos / 8) | 0] << 3; + // shft(pos) now 1 less if pos & 7 != 0 + pos -= 7; + st.h = head, st.p = prev, st.i = i, st.w = wi; + } + } + else { + for (var i = st.w || 0; i < s + lst; i += 65535) { + // end + var e = i + 65535; + if (e >= s) { + // write final block + w[(pos / 8) | 0] = lst; + e = s; + } + pos = wfblk(w, pos + 1, dat.subarray(i, e)); + } + st.i = s; + } + return slc(o, 0, pre + shft(pos) + post); +}; +// CRC32 table +var crct = /*#__PURE__*/ (function () { + var t = new Int32Array(256); + for (var i = 0; i < 256; ++i) { + var c = i, k = 9; + while (--k) + c = ((c & 1) && -306674912) ^ (c >>> 1); + t[i] = c; + } + return t; +})(); +// CRC32 +var crc = function () { + var c = -1; + return { + p: function (d) { + // closures have awful performance + var cr = c; + for (var i = 0; i < d.length; ++i) + cr = crct[(cr & 255) ^ d[i]] ^ (cr >>> 8); + c = cr; + }, + d: function () { return ~c; } + }; +}; +// Adler32 +var adler = function () { + var a = 1, b = 0; + return { + p: function (d) { + // closures have awful performance + var n = a, m = b; + var l = d.length | 0; + for (var i = 0; i != l;) { + var e = Math.min(i + 2655, l); + for (; i < e; ++i) + m += n += d[i]; + n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16); + } + a = n, b = m; + }, + d: function () { + a %= 65521, b %= 65521; + return (a & 255) << 24 | (a & 0xFF00) << 8 | (b & 255) << 8 | (b >> 8); + } + }; +}; +; +// deflate with opts +var dopt = function (dat, opt, pre, post, st) { + if (!st) { + st = { l: 1 }; + if (opt.dictionary) { + var dict = opt.dictionary.subarray(-32768); + var newDat = new u8(dict.length + dat.length); + newDat.set(dict); + newDat.set(dat, dict.length); + dat = newDat; + st.w = dict.length; + } + } + return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? (st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20) : (12 + opt.mem), pre, post, st); +}; +// Walmart object spread +var mrg = function (a, b) { + var o = {}; + for (var k in a) + o[k] = a[k]; + for (var k in b) + o[k] = b[k]; + return o; +}; +// worker clone +// This is possibly the craziest part of the entire codebase, despite how simple it may seem. +// The only parameter to this function is a closure that returns an array of variables outside of the function scope. +// We're going to try to figure out the variable names used in the closure as strings because that is crucial for workerization. +// We will return an object mapping of true variable name to value (basically, the current scope as a JS object). +// The reason we can't just use the original variable names is minifiers mangling the toplevel scope. +// This took me three weeks to figure out how to do. +var wcln = function (fn, fnStr, td) { + var dt = fn(); + var st = fn.toString(); + var ks = st.slice(st.indexOf('[') + 1, st.lastIndexOf(']')).replace(/\s+/g, '').split(','); + for (var i = 0; i < dt.length; ++i) { + var v = dt[i], k = ks[i]; + if (typeof v == 'function') { + fnStr += ';' + k + '='; + var st_1 = v.toString(); + if (v.prototype) { + // for global objects + if (st_1.indexOf('[native code]') != -1) { + var spInd = st_1.indexOf(' ', 8) + 1; + fnStr += st_1.slice(spInd, st_1.indexOf('(', spInd)); + } + else { + fnStr += st_1; + for (var t in v.prototype) + fnStr += ';' + k + '.prototype.' + t + '=' + v.prototype[t].toString(); + } + } + else + fnStr += st_1; + } + else + td[k] = v; + } + return fnStr; +}; +var ch = []; +// clone bufs +var cbfs = function (v) { + var tl = []; + for (var k in v) { + if (v[k].buffer) { + tl.push((v[k] = new v[k].constructor(v[k])).buffer); + } + } + return tl; +}; +// use a worker to execute code +var wrkr = function (fns, init, id, cb) { + if (!ch[id]) { + var fnStr = '', td_1 = {}, m = fns.length - 1; + for (var i = 0; i < m; ++i) + fnStr = wcln(fns[i], fnStr, td_1); + ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 }; + } + var td = mrg({}, ch[id].e); + return (0, node_worker_1.default)(ch[id].c + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb); +}; +// base async inflate fn +var bInflt = function () { return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt]; }; +var bDflt = function () { return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; }; +// gzip extra +var gze = function () { return [gzh, gzhl, wbytes, crc, crct]; }; +// gunzip extra +var guze = function () { return [gzs, gzl]; }; +// zlib extra +var zle = function () { return [zlh, wbytes, adler]; }; +// unzlib extra +var zule = function () { return [zls]; }; +// post buf +var pbf = function (msg) { return postMessage(msg, [msg.buffer]); }; +// get opts +var gopt = function (o) { return o && { + out: o.size && new u8(o.size), + dictionary: o.dictionary +}; }; +// async helper +var cbify = function (dat, opts, fns, init, id, cb) { + var w = wrkr(fns, init, id, function (err, dat) { + w.terminate(); + cb(err, dat); + }); + w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []); + return function () { w.terminate(); }; +}; +// auto stream +var astrm = function (strm) { + strm.ondata = function (dat, final) { return postMessage([dat, final], [dat.buffer]); }; + return function (ev) { + if (ev.data[0]) { + strm.push(ev.data[0], ev.data[1]); + postMessage([ev.data[0].length]); + } + else + strm.flush(ev.data[1]); + }; +}; +// async stream attach +var astrmify = function (fns, strm, opts, init, id, flush, ext) { + var t; + var w = wrkr(fns, init, id, function (err, dat) { + if (err) + w.terminate(), strm.ondata.call(strm, err); + else if (!Array.isArray(dat)) + ext(dat); + else if (dat.length == 1) { + strm.queuedSize -= dat[0]; + if (strm.ondrain) + strm.ondrain(dat[0]); + } + else { + if (dat[1]) + w.terminate(); + strm.ondata.call(strm, err, dat[0], dat[1]); + } + }); + w.postMessage(opts); + strm.queuedSize = 0; + strm.push = function (d, f) { + if (!strm.ondata) + err(5); + if (t) + strm.ondata(err(4, 0, 1), null, !!f); + strm.queuedSize += d.length; + // can fail for cross-realm Uint8Array, but ok - only a small performance penalty + w.postMessage([d, t = f], d.buffer instanceof ArrayBuffer ? [d.buffer] : []); + }; + strm.terminate = function () { w.terminate(); }; + if (flush) { + strm.flush = function (sync) { w.postMessage([0, sync]); }; + } +}; +// read 2 bytes +var b2 = function (d, b) { return d[b] | (d[b + 1] << 8); }; +// read 4 bytes +var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; }; +// read 8 bytes +var b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); }; +// write bytes +var wbytes = function (d, b, v) { + for (; v; ++b) + d[b] = v, v >>>= 8; +}; +// gzip header +var gzh = function (c, o) { + var fn = o.filename; + c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3; // assume Unix + if (o.mtime != 0) + wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1000)); + if (fn) { + c[3] = 8; + for (var i = 0; i <= fn.length; ++i) + c[i + 10] = fn.charCodeAt(i); + } +}; +// gzip footer: -8 to -4 = CRC, -4 to -0 is length +// gzip start +var gzs = function (d) { + if (d[0] != 31 || d[1] != 139 || d[2] != 8) + err(6, 'invalid gzip data'); + var flg = d[3]; + var st = 10; + if (flg & 4) + st += (d[10] | d[11] << 8) + 2; + for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) + ; + return st + (flg & 2); +}; +// gzip length +var gzl = function (d) { + var l = d.length; + return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0; +}; +// gzip header length +var gzhl = function (o) { return 10 + (o.filename ? o.filename.length + 1 : 0); }; +// zlib header +var zlh = function (c, o) { + var lv = o.level, fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2; + c[0] = 120, c[1] = (fl << 6) | (o.dictionary && 32); + c[1] |= 31 - ((c[0] << 8) | c[1]) % 31; + if (o.dictionary) { + var h = adler(); + h.p(o.dictionary); + wbytes(c, 2, h.d()); + } +}; +// zlib start +var zls = function (d, dict) { + if ((d[0] & 15) != 8 || (d[0] >> 4) > 7 || ((d[0] << 8 | d[1]) % 31)) + err(6, 'invalid zlib data'); + if ((d[1] >> 5 & 1) == +!dict) + err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary'); + return (d[1] >> 3 & 4) + 2; +}; +function StrmOpt(opts, cb) { + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + return opts; +} +/** + * Streaming DEFLATE compression + */ +var Deflate = /*#__PURE__*/ (function () { + function Deflate(opts, cb) { + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + this.o = opts || {}; + this.s = { l: 0, i: 32768, w: 32768, z: 32768 }; + // Buffer length must always be 0 mod 32768 for index calculations to be correct when modifying head and prev + // 98304 = 32768 (lookback) + 65536 (common chunk size) + this.b = new u8(98304); + if (this.o.dictionary) { + var dict = this.o.dictionary.subarray(-32768); + this.b.set(dict, 32768 - dict.length); + this.s.i = 32768 - dict.length; + } + } + Deflate.prototype.p = function (c, f) { + this.ondata(dopt(c, this.o, 0, 0, this.s), f); + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Deflate.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (this.s.l) + err(4); + var endLen = chunk.length + this.s.z; + if (endLen > this.b.length) { + if (endLen > 2 * this.b.length - 32768) { + var newBuf = new u8(endLen & -32768); + newBuf.set(this.b.subarray(0, this.s.z)); + this.b = newBuf; + } + var split = this.b.length - this.s.z; + this.b.set(chunk.subarray(0, split), this.s.z); + this.s.z = this.b.length; + this.p(this.b, false); + this.b.set(this.b.subarray(-32768)); + this.b.set(chunk.subarray(split), 32768); + this.s.z = chunk.length - split + 32768; + this.s.i = 32766, this.s.w = 32768; + } + else { + this.b.set(chunk, this.s.z); + this.s.z += chunk.length; + } + this.s.l = final & 1; + if (this.s.z > this.s.w + 8191 || final) { + this.p(this.b, final || false); + this.s.w = this.s.i, this.s.i -= 2; + } + if (final) { + // cleanup unneeded buffers/state to reduce memory usage + this.s = this.o = {}; + this.b = et; + } + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + Deflate.prototype.flush = function (sync) { + if (!this.ondata) + err(5); + if (this.s.l) + err(4); + this.p(this.b, false); + this.s.w = this.s.i, this.s.i -= 2; + // could technically skip writing the type-0 block for (this.s.r & 7) == 0, + // but the deterministic trailer (00 00 FF FF) is useful in some situations + if (sync) { + var c = new u8(6); + c[0] = this.s.r >> 3; + // write empty, non-final type-0 block + var ep = wfblk(c, this.s.r, et); + this.s.r = 0; + this.ondata(c.subarray(0, ep >> 3), false); + } + }; + return Deflate; +}()); +exports.Deflate = Deflate; +/** + * Asynchronous streaming DEFLATE compression + */ +var AsyncDeflate = /*#__PURE__*/ (function () { + function AsyncDeflate(opts, cb) { + astrmify([ + bDflt, + function () { return [astrm, Deflate]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Deflate(ev.data); + onmessage = astrm(strm); + }, 6, 1); + } + return AsyncDeflate; +}()); +exports.AsyncDeflate = AsyncDeflate; +function deflate(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + ], function (ev) { return pbf(deflateSync(ev.data[0], ev.data[1])); }, 0, cb); +} +/** + * Compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @returns The deflated version of the data + */ +function deflateSync(data, opts) { + return dopt(data, opts || {}, 0, 0); +} +/** + * Streaming DEFLATE decompression + */ +var Inflate = /*#__PURE__*/ (function () { + function Inflate(opts, cb) { + // no StrmOpt here to avoid adding to workerizer + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768); + this.s = { i: 0, b: dict ? dict.length : 0 }; + this.o = new u8(32768); + this.p = new u8(0); + if (dict) + this.o.set(dict); + } + Inflate.prototype.e = function (c) { + if (!this.ondata) + err(5); + if (this.d) + err(4); + if (!this.p.length) + this.p = c; + else if (c.length) { + var n = new u8(this.p.length + c.length); + n.set(this.p), n.set(c, this.p.length), this.p = n; + } + }; + Inflate.prototype.c = function (final) { + this.s.i = +(this.d = final || false); + var bts = this.s.b; + var dt = inflt(this.p, this.s, this.o); + this.ondata(slc(dt, bts, this.s.b), this.d); + this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length; + this.p = slc(this.p, (this.s.p / 8) | 0), this.s.p &= 7; + }; + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the final chunk + */ + Inflate.prototype.push = function (chunk, final) { + this.e(chunk), this.c(final); + }; + return Inflate; +}()); +exports.Inflate = Inflate; +/** + * Asynchronous streaming DEFLATE decompression + */ +var AsyncInflate = /*#__PURE__*/ (function () { + function AsyncInflate(opts, cb) { + astrmify([ + bInflt, + function () { return [astrm, Inflate]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Inflate(ev.data); + onmessage = astrm(strm); + }, 7, 0); + } + return AsyncInflate; +}()); +exports.AsyncInflate = AsyncInflate; +function inflate(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt + ], function (ev) { return pbf(inflateSync(ev.data[0], gopt(ev.data[1]))); }, 1, cb); +} +function inflateSync(data, opts) { + return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary); +} +// before you yell at me for not just using extends, my reason is that TS inheritance is hard to workerize. +/** + * Streaming GZIP compression + */ +var Gzip = /*#__PURE__*/ (function () { + function Gzip(opts, cb) { + this.c = crc(); + this.l = 0; + this.v = 1; + Deflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Gzip.prototype.push = function (chunk, final) { + this.c.p(chunk); + this.l += chunk.length; + Deflate.prototype.push.call(this, chunk, final); + }; + Gzip.prototype.p = function (c, f) { + var raw = dopt(c, this.o, this.v && gzhl(this.o), f && 8, this.s); + if (this.v) + gzh(raw, this.o), this.v = 0; + if (f) + wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l); + this.ondata(raw, f); + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + Gzip.prototype.flush = function (sync) { + Deflate.prototype.flush.call(this, sync); + }; + return Gzip; +}()); +exports.Gzip = Gzip; +exports.Compress = Gzip; +/** + * Asynchronous streaming GZIP compression + */ +var AsyncGzip = /*#__PURE__*/ (function () { + function AsyncGzip(opts, cb) { + astrmify([ + bDflt, + gze, + function () { return [astrm, Deflate, Gzip]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Gzip(ev.data); + onmessage = astrm(strm); + }, 8, 1); + } + return AsyncGzip; +}()); +exports.AsyncGzip = AsyncGzip; +exports.AsyncCompress = AsyncGzip; +function gzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + gze, + function () { return [gzipSync]; } + ], function (ev) { return pbf(gzipSync(ev.data[0], ev.data[1])); }, 2, cb); +} +/** + * Compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @returns The gzipped version of the data + */ +function gzipSync(data, opts) { + if (!opts) + opts = {}; + var c = crc(), l = data.length; + c.p(data); + var d = dopt(data, opts, gzhl(opts), 8), s = d.length; + return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d; +} +/** + * Streaming single or multi-member GZIP decompression + */ +var Gunzip = /*#__PURE__*/ (function () { + function Gunzip(opts, cb) { + this.v = 1; + this.r = 0; + Inflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Gunzip.prototype.push = function (chunk, final) { + Inflate.prototype.e.call(this, chunk); + this.r += chunk.length; + if (this.v) { + var p = this.p.subarray(this.v - 1); + var s = p.length > 3 ? gzs(p) : 4; + if (s > p.length) { + if (!final) + return; + } + else if (this.v > 1 && this.onmember) { + this.onmember(this.r - p.length); + } + this.p = p.subarray(s), this.v = 0; + } + // necessary to prevent TS from using the closure value + // This allows for workerization to function correctly + Inflate.prototype.c.call(this, 0); + // process concatenated GZIP + if (this.s.f && !this.s.l) { + this.v = shft(this.s.p) + 9; + this.s = { i: 0 }; + this.o = new u8(0); + this.push(new u8(0), final); + } + else if (final) { + Inflate.prototype.c.call(this, final); + } + }; + return Gunzip; +}()); +exports.Gunzip = Gunzip; +/** + * Asynchronous streaming single or multi-member GZIP decompression + */ +var AsyncGunzip = /*#__PURE__*/ (function () { + function AsyncGunzip(opts, cb) { + var _this = this; + astrmify([ + bInflt, + guze, + function () { return [astrm, Inflate, Gunzip]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Gunzip(ev.data); + strm.onmember = function (offset) { return postMessage(offset); }; + onmessage = astrm(strm); + }, 9, 0, function (offset) { return _this.onmember && _this.onmember(offset); }); + } + return AsyncGunzip; +}()); +exports.AsyncGunzip = AsyncGunzip; +function gunzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt, + guze, + function () { return [gunzipSync]; } + ], function (ev) { return pbf(gunzipSync(ev.data[0], ev.data[1])); }, 3, cb); +} +function gunzipSync(data, opts) { + var st = gzs(data); + if (st + 8 > data.length) + err(6, 'invalid gzip data'); + return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary); +} +/** + * Streaming Zlib compression + */ +var Zlib = /*#__PURE__*/ (function () { + function Zlib(opts, cb) { + this.c = adler(); + this.v = 1; + Deflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be zlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Zlib.prototype.push = function (chunk, final) { + this.c.p(chunk); + Deflate.prototype.push.call(this, chunk, final); + }; + Zlib.prototype.p = function (c, f) { + var raw = dopt(c, this.o, this.v && (this.o.dictionary ? 6 : 2), f && 4, this.s); + if (this.v) + zlh(raw, this.o), this.v = 0; + if (f) + wbytes(raw, raw.length - 4, this.c.d()); + this.ondata(raw, f); + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + Zlib.prototype.flush = function (sync) { + Deflate.prototype.flush.call(this, sync); + }; + return Zlib; +}()); +exports.Zlib = Zlib; +/** + * Asynchronous streaming Zlib compression + */ +var AsyncZlib = /*#__PURE__*/ (function () { + function AsyncZlib(opts, cb) { + astrmify([ + bDflt, + zle, + function () { return [astrm, Deflate, Zlib]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Zlib(ev.data); + onmessage = astrm(strm); + }, 10, 1); + } + return AsyncZlib; +}()); +exports.AsyncZlib = AsyncZlib; +function zlib(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + zle, + function () { return [zlibSync]; } + ], function (ev) { return pbf(zlibSync(ev.data[0], ev.data[1])); }, 4, cb); +} +/** + * Compress data with Zlib + * @param data The data to compress + * @param opts The compression options + * @returns The zlib-compressed version of the data + */ +function zlibSync(data, opts) { + if (!opts) + opts = {}; + var a = adler(); + a.p(data); + var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4); + return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d; +} +/** + * Streaming Zlib decompression + */ +var Unzlib = /*#__PURE__*/ (function () { + function Unzlib(opts, cb) { + Inflate.call(this, opts, cb); + this.v = opts && opts.dictionary ? 2 : 1; + } + /** + * Pushes a chunk to be unzlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Unzlib.prototype.push = function (chunk, final) { + Inflate.prototype.e.call(this, chunk); + if (this.v) { + if (this.p.length < 6 && !final) + return; + this.p = this.p.subarray(zls(this.p, this.v - 1)), this.v = 0; + } + if (final) { + if (this.p.length < 4) + err(6, 'invalid zlib data'); + this.p = this.p.subarray(0, -4); + } + // necessary to prevent TS from using the closure value + // This allows for workerization to function correctly + Inflate.prototype.c.call(this, final); + }; + return Unzlib; +}()); +exports.Unzlib = Unzlib; +/** + * Asynchronous streaming Zlib decompression + */ +var AsyncUnzlib = /*#__PURE__*/ (function () { + function AsyncUnzlib(opts, cb) { + astrmify([ + bInflt, + zule, + function () { return [astrm, Inflate, Unzlib]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Unzlib(ev.data); + onmessage = astrm(strm); + }, 11, 0); + } + return AsyncUnzlib; +}()); +exports.AsyncUnzlib = AsyncUnzlib; +function unzlib(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt, + zule, + function () { return [unzlibSync]; } + ], function (ev) { return pbf(unzlibSync(ev.data[0], gopt(ev.data[1]))); }, 5, cb); +} +function unzlibSync(data, opts) { + return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary); +} +/** + * Streaming GZIP, Zlib, or raw DEFLATE decompression + */ +var Decompress = /*#__PURE__*/ (function () { + function Decompress(opts, cb) { + this.o = StrmOpt.call(this, opts, cb) || {}; + this.G = Gunzip; + this.I = Inflate; + this.Z = Unzlib; + } + // init substream + // overriden by AsyncDecompress + Decompress.prototype.i = function () { + var _this = this; + this.s.ondata = function (dat, final) { + _this.ondata(dat, final); + }; + }; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Decompress.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (!this.s) { + if (this.p && this.p.length) { + var n = new u8(this.p.length + chunk.length); + n.set(this.p), n.set(chunk, this.p.length); + } + else + this.p = chunk; + if (this.p.length > 2) { + this.s = (this.p[0] == 31 && this.p[1] == 139 && this.p[2] == 8) + ? new this.G(this.o) + : ((this.p[0] & 15) != 8 || (this.p[0] >> 4) > 7 || ((this.p[0] << 8 | this.p[1]) % 31)) + ? new this.I(this.o) + : new this.Z(this.o); + this.i(); + this.s.push(this.p, final); + this.p = null; + } + } + else + this.s.push(chunk, final); + }; + return Decompress; +}()); +exports.Decompress = Decompress; +/** + * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression + */ +var AsyncDecompress = /*#__PURE__*/ (function () { + function AsyncDecompress(opts, cb) { + Decompress.call(this, opts, cb); + this.queuedSize = 0; + this.G = AsyncGunzip; + this.I = AsyncInflate; + this.Z = AsyncUnzlib; + } + AsyncDecompress.prototype.i = function () { + var _this = this; + this.s.ondata = function (err, dat, final) { + _this.ondata(err, dat, final); + }; + this.s.ondrain = function (size) { + _this.queuedSize -= size; + if (_this.ondrain) + _this.ondrain(size); + }; + }; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + AsyncDecompress.prototype.push = function (chunk, final) { + this.queuedSize += chunk.length; + Decompress.prototype.push.call(this, chunk, final); + }; + return AsyncDecompress; +}()); +exports.AsyncDecompress = AsyncDecompress; +function decompress(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return (data[0] == 31 && data[1] == 139 && data[2] == 8) + ? gunzip(data, opts, cb) + : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31)) + ? inflate(data, opts, cb) + : unzlib(data, opts, cb); +} +/** + * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +function decompressSync(data, opts) { + return (data[0] == 31 && data[1] == 139 && data[2] == 8) + ? gunzipSync(data, opts) + : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31)) + ? inflateSync(data, opts) + : unzlibSync(data, opts); +} +// flatten a directory structure +var fltn = function (d, p, t, o) { + for (var k in d) { + var val = d[k], n = p + k, op = o; + if (Array.isArray(val)) + op = mrg(o, val[1]), val = val[0]; + if (ArrayBuffer.isView(val)) + t[n] = [val, op]; + else { + t[n += '/'] = [new u8(0), op]; + fltn(val, n, t, o); + } + } +}; +// text encoder +var te = typeof TextEncoder != 'undefined' && /*#__PURE__*/ new TextEncoder(); +// text decoder +var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder(); +// text decoder stream +var tds = 0; +try { + td.decode(et, { stream: true }); + tds = 1; +} +catch (e) { } +// decode UTF8 +var dutf8 = function (d) { + for (var r = '', i = 0;;) { + var c = d[i++]; + var eb = (c > 127) + (c > 223) + (c > 239); + if (i + eb > d.length) + return { s: r, r: slc(d, i - 1) }; + if (!eb) + r += String.fromCharCode(c); + else if (eb == 3) { + c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536, + r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023)); + } + else if (eb & 1) + r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63)); + else + r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)); + } +}; +/** + * Streaming UTF-8 decoding + */ +var DecodeUTF8 = /*#__PURE__*/ (function () { + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is decoded + */ + function DecodeUTF8(cb) { + this.ondata = cb; + if (tds) + this.t = new TextDecoder(); + else + this.p = et; + } + /** + * Pushes a chunk to be decoded from UTF-8 binary + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + DecodeUTF8.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + final = !!final; + if (this.t) { + this.ondata(this.t.decode(chunk, { stream: true }), final); + if (final) { + if (this.t.decode().length) + err(8); + this.t = null; + } + return; + } + if (!this.p) + err(4); + var dat = new u8(this.p.length + chunk.length); + dat.set(this.p); + dat.set(chunk, this.p.length); + var _a = dutf8(dat), s = _a.s, r = _a.r; + if (final) { + if (r.length) + err(8); + this.p = null; + } + else + this.p = r; + this.ondata(s, final); + }; + return DecodeUTF8; +}()); +exports.DecodeUTF8 = DecodeUTF8; +/** + * Streaming UTF-8 encoding + */ +var EncodeUTF8 = /*#__PURE__*/ (function () { + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is encoded + */ + function EncodeUTF8(cb) { + this.ondata = cb; + } + /** + * Pushes a chunk to be encoded to UTF-8 + * @param chunk The string data to push + * @param final Whether this is the last chunk + */ + EncodeUTF8.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (this.d) + err(4); + this.ondata(strToU8(chunk), this.d = final || false); + }; + return EncodeUTF8; +}()); +exports.EncodeUTF8 = EncodeUTF8; +/** + * Converts a string into a Uint8Array for use with compression/decompression methods + * @param str The string to encode + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless decoding a binary string. + * @returns The string encoded in UTF-8/Latin-1 binary + */ +function strToU8(str, latin1) { + if (latin1) { + var ar_1 = new u8(str.length); + for (var i = 0; i < str.length; ++i) + ar_1[i] = str.charCodeAt(i); + return ar_1; + } + if (te) + return te.encode(str); + var l = str.length; + var ar = new u8(str.length + (str.length >> 1)); + var ai = 0; + var w = function (v) { ar[ai++] = v; }; + for (var i = 0; i < l; ++i) { + if (ai + 5 > ar.length) { + var n = new u8(ai + 8 + ((l - i) << 1)); + n.set(ar); + ar = n; + } + var c = str.charCodeAt(i); + if (c < 128 || latin1) + w(c); + else if (c < 2048) + w(192 | (c >> 6)), w(128 | (c & 63)); + else if (c > 55295 && c < 57344) + c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023), + w(240 | (c >> 18)), w(128 | ((c >> 12) & 63)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63)); + else + w(224 | (c >> 12)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63)); + } + return slc(ar, 0, ai); +} +/** + * Converts a Uint8Array to a string + * @param dat The data to decode to string + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless encoding to binary string. + * @returns The original UTF-8/Latin-1 string + */ +function strFromU8(dat, latin1) { + if (latin1) { + var r = ''; + for (var i = 0; i < dat.length; i += 16384) + r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384)); + return r; + } + else if (td) { + return td.decode(dat); + } + else { + var _a = dutf8(dat), s = _a.s, r = _a.r; + if (r.length) + err(8); + return s; + } +} +; +// deflate bit flag +var dbf = function (l) { return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0; }; +// skip local zip header +var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); }; +// read zip header +var zh = function (d, b, z) { + var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl; + var _a = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a[0], su = _a[1], off = _a[2]; + return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off]; +}; +// read zip64 header sizes +var z64hs = function (d, b, l, z, sc, su, off) { + var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l; + var nf = nsc + nsu + noff; + if (z && nf) { + for (; b + 4 < e; b += 4 + b2(d, b + 2)) { + if (b2(d, b) == 1) { + return [ + nsc ? b8(d, b + 4 + 8 * nsu) : sc, + nsu ? b8(d, b + 4) : su, + noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off, + 1 + ]; + } + } + // z == 2 for unknown whether or not zip64 + if (z < 2) + err(13); + } + return [sc, su, off, 0]; +}; +// extra field length +var exfl = function (ex) { + var le = 0; + if (ex) { + for (var k in ex) { + var l = ex[k].length; + if (l > 65535) + err(9); + le += l + 4; + } + } + return le; +}; +// write zip header +var wzh = function (d, b, f, fn, u, c, ce, co) { + var fl = fn.length, ex = f.extra, col = co && co.length; + var exl = exfl(ex); + wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4; + if (ce != null) + d[b++] = 20, d[b++] = f.os; + d[b] = 20, b += 2; // spec compliance? what's that? + d[b++] = (f.flag << 1) | (c < 0 && 8), d[b++] = u && 8; + d[b++] = f.compression & 255, d[b++] = f.compression >> 8; + var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980; + if (y < 0 || y > 119) + err(10); + wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >> 1)), b += 4; + if (c != -1) { + wbytes(d, b, f.crc); + wbytes(d, b + 4, c < 0 ? -c - 2 : c); + wbytes(d, b + 8, f.size); + } + wbytes(d, b + 12, fl); + wbytes(d, b + 14, exl), b += 16; + if (ce != null) { + wbytes(d, b, col); + wbytes(d, b + 6, f.attrs); + wbytes(d, b + 10, ce), b += 14; + } + d.set(fn, b); + b += fl; + if (exl) { + for (var k in ex) { + var exf = ex[k], l = exf.length; + wbytes(d, b, +k); + wbytes(d, b + 2, l); + d.set(exf, b + 4), b += 4 + l; + } + } + if (col) + d.set(co, b), b += col; + return b; +}; +// write zip footer (end of central directory) +var wzf = function (o, b, c, d, e) { + wbytes(o, b, 0x6054B50); // skip disk + wbytes(o, b + 8, c); + wbytes(o, b + 10, c); + wbytes(o, b + 12, d); + wbytes(o, b + 16, e); +}; +/** + * A pass-through stream to keep data uncompressed in a ZIP archive. + */ +var ZipPassThrough = /*#__PURE__*/ (function () { + /** + * Creates a pass-through stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + */ + function ZipPassThrough(filename) { + this.filename = filename; + this.c = crc(); + this.size = 0; + this.compression = 0; + } + /** + * Processes a chunk and pushes to the output stream. You can override this + * method in a subclass for custom behavior, but by default this passes + * the data through. You must call this.ondata(err, chunk, final) at some + * point in this method. + * @param chunk The chunk to process + * @param final Whether this is the last chunk + */ + ZipPassThrough.prototype.process = function (chunk, final) { + this.ondata(null, chunk, final); + }; + /** + * Pushes a chunk to be added. If you are subclassing this with a custom + * compression algorithm, note that you must push data from the source + * file only, pre-compression. + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + ZipPassThrough.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + this.c.p(chunk); + this.size += chunk.length; + if (final) + this.crc = this.c.d(); + // we shouldn't really do this cast, but properly handling ArrayBufferLike + // makes the API unergonomic with Buffer + this.process(chunk, final || false); + }; + return ZipPassThrough; +}()); +exports.ZipPassThrough = ZipPassThrough; +// I don't extend because TypeScript extension adds 1kB of runtime bloat +/** + * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate + * for better performance + */ +var ZipDeflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + function ZipDeflate(filename, opts) { + var _this = this; + if (!opts) + opts = {}; + ZipPassThrough.call(this, filename); + this.d = new Deflate(opts, function (dat, final) { + _this.ondata(null, dat, final); + }); + this.compression = 8; + this.flag = dbf(opts.level); + } + ZipDeflate.prototype.process = function (chunk, final) { + try { + this.d.push(chunk, final); + } + catch (e) { + this.ondata(e, null, final); + } + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + ZipDeflate.prototype.push = function (chunk, final) { + ZipPassThrough.prototype.push.call(this, chunk, final); + }; + return ZipDeflate; +}()); +exports.ZipDeflate = ZipDeflate; +/** + * Asynchronous streaming DEFLATE compression for ZIP archives + */ +var AsyncZipDeflate = /*#__PURE__*/ (function () { + /** + * Creates an asynchronous DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + function AsyncZipDeflate(filename, opts) { + var _this = this; + if (!opts) + opts = {}; + ZipPassThrough.call(this, filename); + this.d = new AsyncDeflate(opts, function (err, dat, final) { + _this.ondata(err, dat, final); + }); + this.compression = 8; + this.flag = dbf(opts.level); + this.terminate = this.d.terminate; + } + AsyncZipDeflate.prototype.process = function (chunk, final) { + this.d.push(chunk, final); + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + AsyncZipDeflate.prototype.push = function (chunk, final) { + ZipPassThrough.prototype.push.call(this, chunk, final); + }; + return AsyncZipDeflate; +}()); +exports.AsyncZipDeflate = AsyncZipDeflate; +// TODO: Better tree shaking +/** + * A zippable archive to which files can incrementally be added + */ +var Zip = /*#__PURE__*/ (function () { + /** + * Creates an empty ZIP archive to which files can be added + * @param cb The callback to call whenever data for the generated ZIP archive + * is available + */ + function Zip(cb) { + this.ondata = cb; + this.u = []; + this.d = 1; + } + /** + * Adds a file to the ZIP archive + * @param file The file stream to add + */ + Zip.prototype.add = function (file) { + var _this = this; + if (!this.ondata) + err(5); + // finishing or finished + if (this.d & 2) + this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, false); + else { + var f = strToU8(file.filename), fl_1 = f.length; + var com = file.comment, o = com && strToU8(com); + var u = fl_1 != file.filename.length || (o && (com.length != o.length)); + var hl_1 = fl_1 + exfl(file.extra) + 30; + if (fl_1 > 65535) + this.ondata(err(11, 0, 1), null, false); + var header = new u8(hl_1); + wzh(header, 0, file, f, u, -1); + var chks_1 = [header]; + var pAll_1 = function () { + for (var _i = 0, chks_2 = chks_1; _i < chks_2.length; _i++) { + var chk = chks_2[_i]; + _this.ondata(null, chk, false); + } + chks_1 = []; + }; + var tr_1 = this.d; + this.d = 0; + var ind_1 = this.u.length; + var uf_1 = mrg(file, { + f: f, + u: u, + o: o, + t: function () { + if (file.terminate) + file.terminate(); + }, + r: function () { + pAll_1(); + if (tr_1) { + var nxt = _this.u[ind_1 + 1]; + if (nxt) + nxt.r(); + else + _this.d = 1; + } + tr_1 = 1; + } + }); + var cl_1 = 0; + file.ondata = function (err, dat, final) { + if (err) { + _this.ondata(err, dat, final); + _this.terminate(); + } + else { + cl_1 += dat.length; + chks_1.push(dat); + if (final) { + var dd = new u8(16); + wbytes(dd, 0, 0x8074B50); + wbytes(dd, 4, file.crc); + wbytes(dd, 8, cl_1); + wbytes(dd, 12, file.size); + chks_1.push(dd); + uf_1.c = cl_1, uf_1.b = hl_1 + cl_1 + 16, uf_1.crc = file.crc, uf_1.size = file.size; + if (tr_1) + uf_1.r(); + tr_1 = 1; + } + else if (tr_1) + pAll_1(); + } + }; + this.u.push(uf_1); + } + }; + /** + * Ends the process of adding files and prepares to emit the final chunks. + * This *must* be called after adding all desired files for the resulting + * ZIP file to work properly. + */ + Zip.prototype.end = function () { + var _this = this; + if (this.d & 2) { + this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, true); + return; + } + if (this.d) + this.e(); + else + this.u.push({ + r: function () { + if (!(_this.d & 1)) + return; + _this.u.splice(-1, 1); + _this.e(); + }, + t: function () { } + }); + this.d = 3; + }; + Zip.prototype.e = function () { + var bt = 0, l = 0, tl = 0; + for (var _i = 0, _a = this.u; _i < _a.length; _i++) { + var f = _a[_i]; + tl += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0); + } + var out = new u8(tl + 22); + for (var _b = 0, _c = this.u; _b < _c.length; _b++) { + var f = _c[_b]; + wzh(out, bt, f, f.f, f.u, -f.c - 2, l, f.o); + bt += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0), l += f.b; + } + wzf(out, bt, this.u.length, tl, l); + this.ondata(null, out, true); + this.d = 2; + }; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to add() will fail. + */ + Zip.prototype.terminate = function () { + for (var _i = 0, _a = this.u; _i < _a.length; _i++) { + var f = _a[_i]; + f.t(); + } + this.d = 2; + }; + return Zip; +}()); +exports.Zip = Zip; +function zip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + var r = {}; + fltn(data, '', r, opts); + var k = Object.keys(r); + var lft = k.length, o = 0, tot = 0; + var slft = lft, files = new Array(lft); + var term = []; + var tAll = function () { + for (var i = 0; i < term.length; ++i) + term[i](); + }; + var cbd = function (a, b) { + mt(function () { cb(a, b); }); + }; + mt(function () { cbd = cb; }); + var cbf = function () { + var out = new u8(tot + 22), oe = o, cdl = tot - o; + tot = 0; + for (var i = 0; i < slft; ++i) { + var f = files[i]; + try { + var l = f.c.length; + wzh(out, tot, f, f.f, f.u, l); + var badd = 30 + f.f.length + exfl(f.extra); + var loc = tot + badd; + out.set(f.c, loc); + wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l; + } + catch (e) { + return cbd(e, null); + } + } + wzf(out, o, files.length, cdl, oe); + cbd(null, out); + }; + if (!lft) + cbf(); + var _loop_1 = function (i) { + var fn = k[i]; + var _a = r[fn], file = _a[0], p = _a[1]; + var c = crc(), size = file.length; + c.p(file); + var f = strToU8(fn), s = f.length; + var com = p.comment, m = com && strToU8(com), ms = m && m.length; + var exl = exfl(p.extra); + var compression = p.level == 0 ? 0 : 8; + var cbl = function (e, d) { + if (e) { + tAll(); + cbd(e, null); + } + else { + var l = d.length; + files[i] = mrg(p, { + size: size, + crc: c.d(), + c: d, + f: f, + m: m, + u: s != fn.length || (m && (com.length != ms)), + compression: compression + }); + o += 30 + s + exl + l; + tot += 76 + 2 * (s + exl) + (ms || 0) + l; + if (!--lft) + cbf(); + } + }; + if (s > 65535) + cbl(err(11, 0, 1), null); + if (!compression) + cbl(null, file); + else if (size < 160000) { + try { + cbl(null, deflateSync(file, p)); + } + catch (e) { + cbl(e, null); + } + } + else + term.push(deflate(file, p, cbl)); + }; + // Cannot use lft because it can decrease + for (var i = 0; i < slft; ++i) { + _loop_1(i); + } + return tAll; +} +/** + * Synchronously creates a ZIP file. Prefer using `zip` for better performance + * with more than one file. + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @returns The generated ZIP archive + */ +function zipSync(data, opts) { + if (!opts) + opts = {}; + var r = {}; + var files = []; + fltn(data, '', r, opts); + var o = 0; + var tot = 0; + for (var fn in r) { + var _a = r[fn], file = _a[0], p = _a[1]; + var compression = p.level == 0 ? 0 : 8; + var f = strToU8(fn), s = f.length; + var com = p.comment, m = com && strToU8(com), ms = m && m.length; + var exl = exfl(p.extra); + if (s > 65535) + err(11); + var d = compression ? deflateSync(file, p) : file, l = d.length; + var c = crc(); + c.p(file); + files.push(mrg(p, { + size: file.length, + crc: c.d(), + c: d, + f: f, + m: m, + u: s != fn.length || (m && (com.length != ms)), + o: o, + compression: compression + })); + o += 30 + s + exl + l; + tot += 76 + 2 * (s + exl) + (ms || 0) + l; + } + var out = new u8(tot + 22), oe = o, cdl = tot - o; + for (var i = 0; i < files.length; ++i) { + var f = files[i]; + wzh(out, f.o, f, f.f, f.u, f.c.length); + var badd = 30 + f.f.length + exfl(f.extra); + out.set(f.c, f.o + badd); + wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0); + } + wzf(out, o, files.length, cdl, oe); + return out; +} +/** + * Streaming pass-through decompression for ZIP archives + */ +var UnzipPassThrough = /*#__PURE__*/ (function () { + function UnzipPassThrough() { + } + UnzipPassThrough.prototype.push = function (chunk, final) { + // same as ZipPassThrough: cast to retain Buffer ergonomics + this.ondata(null, chunk, final); + }; + UnzipPassThrough.compression = 0; + return UnzipPassThrough; +}()); +exports.UnzipPassThrough = UnzipPassThrough; +/** + * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for + * better performance. + */ +var UnzipInflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + function UnzipInflate() { + var _this = this; + this.i = new Inflate(function (dat, final) { + _this.ondata(null, dat, final); + }); + } + UnzipInflate.prototype.push = function (chunk, final) { + try { + this.i.push(chunk, final); + } + catch (e) { + this.ondata(e, null, final); + } + }; + UnzipInflate.compression = 8; + return UnzipInflate; +}()); +exports.UnzipInflate = UnzipInflate; +/** + * Asynchronous streaming DEFLATE decompression for ZIP archives + */ +var AsyncUnzipInflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + function AsyncUnzipInflate(_, sz) { + var _this = this; + if (sz < 320000) { + this.i = new Inflate(function (dat, final) { + _this.ondata(null, dat, final); + }); + } + else { + this.i = new AsyncInflate(function (err, dat, final) { + _this.ondata(err, dat, final); + }); + this.terminate = this.i.terminate; + } + } + AsyncUnzipInflate.prototype.push = function (chunk, final) { + if (this.i.terminate) + chunk = slc(chunk, 0); + this.i.push(chunk, final); + }; + AsyncUnzipInflate.compression = 8; + return AsyncUnzipInflate; +}()); +exports.AsyncUnzipInflate = AsyncUnzipInflate; +/** + * A ZIP archive decompression stream that emits files as they are discovered + */ +var Unzip = /*#__PURE__*/ (function () { + /** + * Creates a ZIP decompression stream + * @param cb The callback to call whenever a file in the ZIP archive is found + */ + function Unzip(cb) { + this.onfile = cb; + this.k = []; + this.o = { + 0: UnzipPassThrough + }; + this.p = et; + } + /** + * Pushes a chunk to be unzipped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Unzip.prototype.push = function (chunk, final) { + var _this = this; + if (!this.onfile) + err(5); + if (!this.p) + err(4); + if (this.c > 0) { + var len = Math.min(this.c, chunk.length); + var toAdd = chunk.subarray(0, len); + this.c -= len; + if (this.d) + this.d.push(toAdd, !this.c); + else + this.k[0].push(toAdd); + chunk = chunk.subarray(len); + if (chunk.length) + return this.push(chunk, final); + } + else { + var f = 0, i = 0, is = void 0, buf = void 0; + if (!this.p.length) + buf = chunk; + else if (!chunk.length) + buf = this.p; + else { + buf = new u8(this.p.length + chunk.length); + buf.set(this.p), buf.set(chunk, this.p.length); + } + var l = buf.length, oc = this.c, add = oc && this.d; + var _loop_2 = function () { + var sig = b4(buf, i); + if (sig == 0x4034B50) { + f = 1, is = i; + this_1.d = null; + this_1.c = 0; + var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28); + if (l > i + 30 + fnl + es) { + var chks_3 = []; + this_1.k.unshift(chks_3); + f = 2; + var lsc = b4(buf, i + 18), lsu = b4(buf, i + 22); + var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u); + var _a = z64hs(buf, i, es, 2, lsc, lsu, 0), sc_1 = _a[0], su_1 = _a[1], z64 = _a[3]; + if (dd) + sc_1 = -1 - z64; + i += es; + this_1.c = sc_1; + var d_1; + var file_1 = { + name: fn_1, + compression: cmp_1, + start: function () { + if (!file_1.ondata) + err(5); + if (!sc_1) + file_1.ondata(null, et, true); + else { + var ctr = _this.o[cmp_1]; + if (!ctr) + file_1.ondata(err(14, 'unknown compression type ' + cmp_1, 1), null, false); + d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1); + d_1.ondata = function (err, dat, final) { file_1.ondata(err, dat, final); }; + for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) { + var dat = chks_4[_i]; + d_1.push(dat, false); + } + if (_this.k[0] == chks_3 && _this.c) + _this.d = d_1; + else + d_1.push(et, true); + } + }, + terminate: function () { + if (d_1 && d_1.terminate) + d_1.terminate(); + } + }; + if (sc_1 >= 0) + file_1.size = sc_1, file_1.originalSize = su_1; + this_1.onfile(file_1); + } + return "break"; + } + else if (oc) { + if (sig == 0x8074B50) { + is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0; + return "break"; + } + else if (sig == 0x2014B50) { + is = i -= 4, f = 3, this_1.c = 0; + return "break"; + } + } + }; + var this_1 = this; + for (; i < l - 4; ++i) { + var state_1 = _loop_2(); + if (state_1 === "break") + break; + } + this.p = et; + if (oc < 0) { + var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 0x8074B50 && 4)) : buf.subarray(0, i); + if (add) + add.push(dat, !!f); + else + this.k[+(f == 2)].push(dat); + } + if (f & 2) + return this.push(buf.subarray(i), final); + this.p = buf.subarray(i); + } + if (final) { + if (this.c) + err(13); + this.p = null; + } + }; + /** + * Registers a decoder with the stream, allowing for files compressed with + * the compression type provided to be expanded correctly + * @param decoder The decoder constructor + */ + Unzip.prototype.register = function (decoder) { + this.o[decoder.compression] = decoder; + }; + return Unzip; +}()); +exports.Unzip = Unzip; +var mt = typeof queueMicrotask == 'function' ? queueMicrotask : typeof setTimeout == 'function' ? setTimeout : function (fn) { fn(); }; +function unzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + var term = []; + var tAll = function () { + for (var i = 0; i < term.length; ++i) + term[i](); + }; + var files = {}; + var cbd = function (a, b) { + mt(function () { cb(a, b); }); + }; + mt(function () { cbd = cb; }); + var e = data.length - 22; + for (; b4(data, e) != 0x6054B50; --e) { + if (!e || data.length - e > 65558) { + cbd(err(13, 0, 1), null); + return tAll; + } + } + ; + var lft = b2(data, e + 8); + if (lft) { + var c = lft; + var o = b4(data, e + 16); + var z = b4(data, e - 20) == 0x7064B50; + if (z) { + var ze = b4(data, e - 12); + z = b4(data, ze) == 0x6064B50; + if (z) { + c = lft = b4(data, ze + 32); + o = b4(data, ze + 48); + } + } + var fltr = opts && opts.filter; + var _loop_3 = function (i) { + var _a = zh(data, o, z), c_1 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off); + o = no; + var cbl = function (e, d) { + if (e) { + tAll(); + cbd(e, null); + } + else { + if (d) + files[fn] = d; + if (!--lft) + cbd(null, files); + } + }; + if (!fltr || fltr({ + name: fn, + size: sc, + originalSize: su, + compression: c_1 + })) { + if (!c_1) + cbl(null, slc(data, b, b + sc)); + else if (c_1 == 8) { + var infl = data.subarray(b, b + sc); + // Synchronously decompress under 512KB, or barely-compressed data + if (su < 524288 || sc > 0.8 * su) { + try { + cbl(null, inflateSync(infl, { out: new u8(su) })); + } + catch (e) { + cbl(e, null); + } + } + else + term.push(inflate(infl, { size: su }, cbl)); + } + else + cbl(err(14, 'unknown compression type ' + c_1, 1), null); + } + else + cbl(null, null); + }; + for (var i = 0; i < c; ++i) { + _loop_3(i); + } + } + else + cbd(null, {}); + return tAll; +} +/** + * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better + * performance with more than one file. + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @returns The decompressed files + */ +function unzipSync(data, opts) { + var files = {}; + var e = data.length - 22; + for (; b4(data, e) != 0x6054B50; --e) { + if (!e || data.length - e > 65558) + err(13); + } + ; + var c = b2(data, e + 8); + if (!c) + return {}; + var o = b4(data, e + 16); + var z = b4(data, e - 20) == 0x7064B50; + if (z) { + var ze = b4(data, e - 12); + z = b4(data, ze) == 0x6064B50; + if (z) { + c = b4(data, ze + 32); + o = b4(data, ze + 48); + } + } + var fltr = opts && opts.filter; + for (var i = 0; i < c; ++i) { + var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off); + o = no; + if (!fltr || fltr({ + name: fn, + size: sc, + originalSize: su, + compression: c_2 + })) { + if (!c_2) + files[fn] = slc(data, b, b + sc); + else if (c_2 == 8) + files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) }); + else + err(14, 'unknown compression type ' + c_2); + } + } + return files; +} diff --git a/tools/ui/node_modules/fflate/lib/index.d.ts b/tools/ui/node_modules/fflate/lib/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d430faf2b555c978d66c89f46155b72c2c45a971 --- /dev/null +++ b/tools/ui/node_modules/fflate/lib/index.d.ts @@ -0,0 +1,1539 @@ +/** + * Codes for errors generated within this library + */ +export declare const FlateErrorCode: { + readonly UnexpectedEOF: 0; + readonly InvalidBlockType: 1; + readonly InvalidLengthLiteral: 2; + readonly InvalidDistance: 3; + readonly StreamFinished: 4; + readonly NoStreamHandler: 5; + readonly InvalidHeader: 6; + readonly NoCallback: 7; + readonly InvalidUTF8: 8; + readonly ExtraFieldTooLong: 9; + readonly InvalidDate: 10; + readonly FilenameTooLong: 11; + readonly StreamFinishing: 12; + readonly InvalidZipData: 13; + readonly UnknownCompressionMethod: 14; +}; +/** + * An error generated within this library + */ +export interface FlateError extends Error { + /** + * The code associated with this error + */ + code: number; +} +/** + * Options for decompressing a DEFLATE stream + */ +export interface InflateStreamOptions { + /** + * The dictionary used to compress the original data. If no dictionary was used during compression, this option has no effect. + * + * Supplying the wrong dictionary during decompression usually yields corrupt output or causes an invalid distance error. + */ + dictionary?: Uint8Array; +} +/** + * Options for decompressing DEFLATE data + */ +export interface InflateOptions extends InflateStreamOptions { + /** + * The buffer into which to write the decompressed data. Saves memory if you know the decompressed size in advance. + * + * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit. + */ + out?: Uint8Array; +} +/** + * Options for decompressing a GZIP stream + */ +export interface GunzipStreamOptions extends InflateStreamOptions { +} +/** + * Options for decompressing GZIP data + */ +export interface GunzipOptions extends InflateStreamOptions { + /** + * The buffer into which to write the decompressed data. GZIP already encodes the output size, so providing this doesn't save memory. + * + * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit. + */ + out?: Uint8Array; +} +/** + * Options for decompressing a Zlib stream + */ +export interface UnzlibStreamOptions extends InflateStreamOptions { +} +/** + * Options for decompressing Zlib data + */ +export interface UnzlibOptions extends InflateOptions { +} +/** + * Options for compressing data into a DEFLATE format + */ +export interface DeflateOptions { + /** + * The level of compression to use, ranging from 0-9. + * + * 0 will store the data without compression. + * 1 is fastest but compresses the worst, 9 is slowest but compresses the best. + * The default level is 6. + * + * Typically, binary data benefits much more from higher values than text data. + * In both cases, higher values usually take disproportionately longer than the reduction in final size that results. + * + * For example, a 1 MB text file could: + * - become 1.01 MB with level 0 in 1ms + * - become 400 kB with level 1 in 10ms + * - become 320 kB with level 9 in 100ms + */ + level?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + /** + * The memory level to use, ranging from 0-12. Increasing this increases speed and compression ratio at the cost of memory. + * + * Note that this is exponential: while level 0 uses 8 kB, level 4 uses 128 kB, level 8 uses 2 MB, and level 12 uses 32 MB. + * It is recommended not to lower the value below 4, since that tends to hurt performance. + * In addition, values above 8 tend to help very little on most data and can even hurt performance. + * + * The default value is automatically determined based on the size of the input data. + */ + mem?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12; + /** + * A buffer containing common byte sequences in the input data that can be used to significantly improve compression ratios. + * + * Dictionaries should be 32kB or smaller and include strings or byte sequences likely to appear in the input. + * The decompressor must supply the same dictionary as the compressor to extract the original data. + * + * Dictionaries only improve aggregate compression ratio when reused across multiple small inputs. They should typically not be used otherwise. + * + * Avoid using dictionaries with GZIP and ZIP to maximize software compatibility. + */ + dictionary?: Uint8Array; +} +/** + * Options for compressing data into a GZIP format + */ +export interface GzipOptions extends DeflateOptions { + /** + * When the file was last modified. Defaults to the current time. + * Set this to 0 to avoid revealing a modification date entirely. + */ + mtime?: Date | string | number; + /** + * The filename of the data. If the `gunzip` command is used to decompress the data, it will output a file + * with this name instead of the name of the compressed file. + */ + filename?: string; +} +/** + * Options for compressing data into a Zlib format + */ +export interface ZlibOptions extends DeflateOptions { +} +/** + * Handler for data (de)compression streams + * @param data The data output from the stream processor + * @param final Whether this is the final block + */ +export type FlateStreamHandler = (data: Uint8Array, final: boolean) => void; +/** + * Handler for asynchronous data (de)compression streams + * @param err Any error that occurred + * @param data The data output from the stream processor + * @param final Whether this is the final block + */ +export type AsyncFlateStreamHandler = (err: FlateError | null, data: Uint8Array, final: boolean) => void; +/** + * Handler for the asynchronous completion of (de)compression for a data chunk + * @param size The number of bytes that were processed. This is measured in terms of the input + * (i.e. compressed bytes for decompression, uncompressed bytes for compression.) + */ +export type AsyncFlateDrainHandler = (size: number) => void; +/** + * Callback for asynchronous (de)compression methods + * @param err Any error that occurred + * @param data The resulting data. Only present if `err` is null + */ +export type FlateCallback = (err: FlateError | null, data: Uint8Array) => void; +interface AsyncOptions { + /** + * Whether or not to "consume" the source data. This will make the typed array/buffer you pass in + * unusable but will increase performance and reduce memory usage. + */ + consume?: boolean; +} +/** + * Options for compressing data asynchronously into a DEFLATE format + */ +export interface AsyncDeflateOptions extends DeflateOptions, AsyncOptions { +} +/** + * Options for decompressing DEFLATE data asynchronously + */ +export interface AsyncInflateOptions extends AsyncOptions, InflateStreamOptions { + /** + * The original size of the data. Currently, the asynchronous API disallows + * writing into a buffer you provide; the best you can do is provide the + * size in bytes and be given back a new typed array. + */ + size?: number; +} +/** + * Options for compressing data asynchronously into a GZIP format + */ +export interface AsyncGzipOptions extends GzipOptions, AsyncOptions { +} +/** + * Options for decompressing GZIP data asynchronously + */ +export interface AsyncGunzipOptions extends AsyncOptions, InflateStreamOptions { +} +/** + * Options for compressing data asynchronously into a Zlib format + */ +export interface AsyncZlibOptions extends ZlibOptions, AsyncOptions { +} +/** + * Options for decompressing Zlib data asynchronously + */ +export interface AsyncUnzlibOptions extends AsyncInflateOptions { +} +/** + * A terminable compression/decompression process + */ +export interface AsyncTerminable { + /** + * Terminates the worker thread immediately. The callback will not be called. + */ + (): void; +} +/** + * Streaming DEFLATE compression + */ +export declare class Deflate { + /** + * Creates a DEFLATE stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: DeflateOptions, cb?: FlateStreamHandler); + /** + * Creates a DEFLATE stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + private b; + private s; + private o; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + private p; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE compression + */ +export declare class AsyncDeflate { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous DEFLATE stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: DeflateOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous DEFLATE stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function deflate(data: Uint8Array, opts: AsyncDeflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param cb The function to be called upon compression completion + */ +export declare function deflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @returns The deflated version of the data + */ +export declare function deflateSync(data: Uint8Array, opts?: DeflateOptions): Uint8Array; +/** + * Streaming DEFLATE decompression + */ +export declare class Inflate { + private s; + private o; + private p; + private d; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a DEFLATE decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: InflateStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a DEFLATE decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + private e; + private c; + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the final chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE decompression + */ +export declare class AsyncInflate { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous DEFLATE decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: InflateStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous DEFLATE decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function inflate(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function inflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands DEFLATE data with no wrapper + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function inflateSync(data: Uint8Array): Uint8Array; +/** + * Expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function inflateSync(data: Uint8Array, opts?: InflateOptions): Uint8Array; +/** + * Streaming GZIP compression + */ +export declare class Gzip { + private c; + private l; + private v; + private o; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a GZIP stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: GzipOptions, cb?: FlateStreamHandler); + /** + * Creates a GZIP stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + private p; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming GZIP compression + */ +export declare class AsyncGzip { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous GZIP stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: GzipOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous GZIP stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function gzip(data: Uint8Array, opts: AsyncGzipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with GZIP + * @param data The data to compress + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @returns The gzipped version of the data + */ +export declare function gzipSync(data: Uint8Array, opts?: GzipOptions): Uint8Array; +/** + * Handler for new GZIP members in concatenated GZIP streams. Useful for building indices used to perform random-access reads on compressed files. + * @param offset The offset of the new member relative to the start of the stream + */ +export type GunzipMemberHandler = (offset: number) => void; +/** + * Streaming single or multi-member GZIP decompression + */ +export declare class Gunzip { + private v; + private r; + private o; + private p; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * The handler to call whenever a new GZIP member is found + */ + onmember?: GunzipMemberHandler; + /** + * Creates a GUNZIP stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: GunzipStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a GUNZIP stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming single or multi-member GZIP decompression + */ +export declare class AsyncGunzip { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * The handler to call whenever a new GZIP member is found + */ + onmember?: GunzipMemberHandler; + /** + * Creates an asynchronous GUNZIP stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: GunzipStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous GUNZIP stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands GZIP data + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gunzip(data: Uint8Array, opts: AsyncGunzipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands GZIP data + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gunzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands GZIP data + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function gunzipSync(data: Uint8Array): Uint8Array; +/** + * Expands GZIP data + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function gunzipSync(data: Uint8Array, opts?: GunzipOptions): Uint8Array; +/** + * Streaming Zlib compression + */ +export declare class Zlib { + private c; + private v; + private o; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a Zlib stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: ZlibOptions, cb?: FlateStreamHandler); + /** + * Creates a Zlib stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be zlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + private p; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming Zlib compression + */ +export declare class AsyncZlib { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous Zlib stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: ZlibOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous Zlib stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with Zlib + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + */ +export declare function zlib(data: Uint8Array, opts: AsyncZlibOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with Zlib + * @param data The data to compress + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compress data with Zlib + * @param data The data to compress + * @param opts The compression options + * @returns The zlib-compressed version of the data + */ +export declare function zlibSync(data: Uint8Array, opts?: ZlibOptions): Uint8Array; +/** + * Streaming Zlib decompression + */ +export declare class Unzlib { + private v; + private p; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a Zlib decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: UnzlibStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a Zlib decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be unzlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming Zlib decompression + */ +export declare class AsyncUnzlib { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous Zlib decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: UnzlibStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous Zlib decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be decompressed from Zlib + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands Zlib data + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function unzlib(data: Uint8Array, opts: AsyncUnzlibOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands Zlib data + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function unzlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands Zlib data + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function unzlibSync(data: Uint8Array): Uint8Array; +/** + * Expands Zlib data + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function unzlibSync(data: Uint8Array, opts?: UnzlibOptions): Uint8Array; +export { gzip as compress, AsyncGzip as AsyncCompress }; +export { gzipSync as compressSync, Gzip as Compress }; +/** + * Streaming GZIP, Zlib, or raw DEFLATE decompression + */ +export declare class Decompress { + private G; + private I; + private Z; + private o; + private s; + private p; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is decompressed + */ + constructor(opts: InflateStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a decompression stream + * @param cb The callback to call whenever data is decompressed + */ + constructor(cb?: FlateStreamHandler); + private i; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression + */ +export declare class AsyncDecompress { + private G; + private I; + private Z; + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is decompressed + */ + constructor(opts: InflateStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous decompression stream + * @param cb The callback to call whenever data is decompressed + */ + constructor(cb?: AsyncFlateStreamHandler); + private i; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function decompress(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function decompress(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function decompressSync(data: Uint8Array, opts?: InflateOptions): Uint8Array; +/** + * Attributes for files added to a ZIP archive object + */ +export interface ZipAttributes { + /** + * The operating system of origin for this file. The value is defined + * by PKZIP's APPNOTE.txt, section 4.4.2.2. For example, 0 (the default) + * is MS/DOS, 3 is Unix, 19 is macOS. + */ + os?: number; + /** + * The file's attributes. These are traditionally somewhat complicated + * and platform-dependent, so using them is scarcely necessary. However, + * here is a representation of what this is, bit by bit: + * + * `TTTTugtrwxrwxrwx0000000000ADVSHR` + * + * TTTT = file type (rarely useful) + * + * u = setuid, g = setgid, t = sticky + * + * rwx = user permissions, rwx = group permissions, rwx = other permissions + * + * 0000000000 = unused + * + * A = archive, D = directory, V = volume label, S = system file, H = hidden, R = read-only + * + * If you want to set the Unix permissions, for instance, just bit shift by 16, e.g. 0o644 << 16. + * Note that attributes usually only work in conjunction with the `os` setting: you must use + * `os` = 3 (Unix) if you want to set Unix permissions + */ + attrs?: number; + /** + * Extra metadata to add to the file. This field is defined by PKZIP's APPNOTE.txt, + * section 4.4.28. At most 65,535 bytes may be used in each ID. The ID must be an + * integer between 0 and 65,535, inclusive. + * + * This field is incredibly rare and almost never needed except for compliance with + * proprietary standards and software. + */ + extra?: Record; + /** + * The comment to attach to the file. This field is defined by PKZIP's APPNOTE.txt, + * section 4.4.26. The comment must be at most 65,535 bytes long UTF-8 encoded. This + * field is not read by consumer software. + */ + comment?: string; + /** + * When the file was last modified. Defaults to the current time. + */ + mtime?: GzipOptions['mtime']; +} +/** + * Options for creating a ZIP archive + */ +export interface ZipOptions extends DeflateOptions, ZipAttributes { +} +/** + * Options for expanding a ZIP archive + */ +export interface UnzipOptions { + /** + * A filter function to extract only certain files from a ZIP archive + */ + filter?: UnzipFileFilter; +} +/** + * Options for asynchronously creating a ZIP archive + */ +export interface AsyncZipOptions extends AsyncDeflateOptions, ZipAttributes { +} +/** + * Options for asynchronously expanding a ZIP archive + */ +export interface AsyncUnzipOptions extends UnzipOptions { +} +/** + * A file that can be used to create a ZIP archive + */ +export type ZippableFile = Uint8Array | Zippable | [Uint8Array | Zippable, ZipOptions]; +/** + * A file that can be used to asynchronously create a ZIP archive + */ +export type AsyncZippableFile = Uint8Array | AsyncZippable | [Uint8Array | AsyncZippable, AsyncZipOptions]; +/** + * The complete directory structure of a ZIPpable archive + */ +export interface Zippable { + [path: string]: ZippableFile; +} +/** + * The complete directory structure of an asynchronously ZIPpable archive + */ +export interface AsyncZippable { + [path: string]: AsyncZippableFile; +} +/** + * An unzipped archive. The full path of each file is used as the key, + * and the file is the value + */ +export interface Unzipped { + [path: string]: Uint8Array; +} +/** + * Handler for string generation streams + * @param data The string output from the stream processor + * @param final Whether this is the final block + */ +export type StringStreamHandler = (data: string, final: boolean) => void; +/** + * Callback for asynchronous ZIP decompression + * @param err Any error that occurred + * @param data The decompressed ZIP archive + */ +export type UnzipCallback = (err: FlateError | null, data: Unzipped) => void; +/** + * Handler for streaming ZIP decompression + * @param file The file that was found in the archive + */ +export type UnzipFileHandler = (file: UnzipFile) => void; +/** + * Streaming UTF-8 decoding + */ +export declare class DecodeUTF8 { + private p; + private t; + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is decoded + */ + constructor(cb?: StringStreamHandler); + /** + * Pushes a chunk to be decoded from UTF-8 binary + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * The handler to call whenever data is available + */ + ondata: StringStreamHandler; +} +/** + * Streaming UTF-8 encoding + */ +export declare class EncodeUTF8 { + private d; + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is encoded + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be encoded to UTF-8 + * @param chunk The string data to push + * @param final Whether this is the last chunk + */ + push(chunk: string, final?: boolean): void; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; +} +/** + * Converts a string into a Uint8Array for use with compression/decompression methods + * @param str The string to encode + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless decoding a binary string. + * @returns The string encoded in UTF-8/Latin-1 binary + */ +export declare function strToU8(str: string, latin1?: boolean): Uint8Array; +/** + * Converts a Uint8Array to a string + * @param dat The data to decode to string + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless encoding to binary string. + * @returns The original UTF-8/Latin-1 string + */ +export declare function strFromU8(dat: Uint8Array, latin1?: boolean): string; +/** + * A stream that can be used to create a file in a ZIP archive + */ +export interface ZipInputFile extends ZipAttributes { + /** + * The filename to associate with the data provided to this stream. If you + * want a file in a subdirectory, use forward slashes as a separator (e.g. + * `directory/filename.ext`). This will still work on Windows. + */ + filename: string; + /** + * The size of the file in bytes. This attribute may be invalid after + * the file is added to the ZIP archive; it must be correct only before the + * stream completes. + * + * If you don't want to have to compute this yourself, consider extending the + * ZipPassThrough class and overriding its process() method, or using one of + * ZipDeflate or AsyncZipDeflate. + */ + size: number; + /** + * A CRC of the original file contents. This attribute may be invalid after + * the file is added to the ZIP archive; it must be correct only before the + * stream completes. + * + * If you don't want to have to generate this yourself, consider extending the + * ZipPassThrough class and overriding its process() method, or using one of + * ZipDeflate or AsyncZipDeflate. + */ + crc: number; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA + */ + compression: number; + /** + * Bits 1 and 2 of the general purpose bit flag, specified in PKZIP's + * APPNOTE.txt, section 4.4.4. Should be between 0 and 3. This is unlikely + * to be necessary. + */ + flag?: number; + /** + * The handler to be called when data is added. After passing this stream to + * the ZIP file object, this handler will always be defined. To call it: + * + * `stream.ondata(error, chunk, final)` + * + * error = any error that occurred (null if there was no error) + * + * chunk = a Uint8Array of the data that was added (null if there was an + * error) + * + * final = boolean, whether this is the final chunk in the stream + */ + ondata?: AsyncFlateStreamHandler; + /** + * A method called when the stream is no longer needed, for clean-up + * purposes. This will not always be called after the stream completes, + * so you may wish to call this.terminate() after the final chunk is + * processed if you have clean-up logic. + */ + terminate?: AsyncTerminable; +} +/** + * A pass-through stream to keep data uncompressed in a ZIP archive. + */ +export declare class ZipPassThrough implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private c; + /** + * Creates a pass-through stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + */ + constructor(filename: string); + /** + * Processes a chunk and pushes to the output stream. You can override this + * method in a subclass for custom behavior, but by default this passes + * the data through. You must call this.ondata(err, chunk, final) at some + * point in this method. + * @param chunk The chunk to process + * @param final Whether this is the last chunk + */ + protected process(chunk: Uint8Array, final: boolean): void; + /** + * Pushes a chunk to be added. If you are subclassing this with a custom + * compression algorithm, note that you must push data from the source + * file only, pre-compression. + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate + * for better performance + */ +export declare class ZipDeflate implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + flag: 0 | 1 | 2 | 3; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private d; + /** + * Creates a DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + constructor(filename: string, opts?: DeflateOptions); + private process; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE compression for ZIP archives + */ +export declare class AsyncZipDeflate implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + flag: 0 | 1 | 2 | 3; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private d; + terminate: AsyncTerminable; + /** + * Creates an asynchronous DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + constructor(filename: string, opts?: DeflateOptions); + private process; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * A zippable archive to which files can incrementally be added + */ +export declare class Zip { + private u; + private d; + /** + * Creates an empty ZIP archive to which files can be added + * @param cb The callback to call whenever data for the generated ZIP archive + * is available + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Adds a file to the ZIP archive + * @param file The file stream to add + */ + add(file: ZipInputFile): void; + /** + * Ends the process of adding files and prepares to emit the final chunks. + * This *must* be called after adding all desired files for the resulting + * ZIP file to work properly. + */ + end(): void; + private e; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to add() will fail. + */ + terminate(): void; + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; +} +/** + * Asynchronously creates a ZIP file + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @param cb The callback to call with the generated ZIP archive + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zip(data: AsyncZippable, opts: AsyncZipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously creates a ZIP file + * @param data The directory structure for the ZIP archive + * @param cb The callback to call with the generated ZIP archive + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zip(data: AsyncZippable, cb: FlateCallback): AsyncTerminable; +/** + * Synchronously creates a ZIP file. Prefer using `zip` for better performance + * with more than one file. + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @returns The generated ZIP archive + */ +export declare function zipSync(data: Zippable, opts?: ZipOptions): Uint8Array; +/** + * A decoder for files in ZIP streams + */ +export interface UnzipDecoder { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * Pushes a chunk to be decompressed + * @param chunk The data in this chunk. Do not consume (detach) this buffer. + * @param final Whether this is the last chunk in the data stream + */ + push(chunk: Uint8Array, final: boolean): void; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to push() should silently fail. + */ + terminate?: AsyncTerminable; +} +/** + * A constructor for a decoder for unzip streams + */ +export interface UnzipDecoderConstructor { + /** + * Creates an instance of the decoder + * @param filename The name of the file + * @param size The compressed size of the file + * @param originalSize The original size of the file + */ + new (filename: string, size?: number, originalSize?: number): UnzipDecoder; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA + */ + compression: number; +} +/** + * Information about a file to be extracted from a ZIP archive + */ +export interface UnzipFileInfo { + /** + * The name of the file + */ + name: string; + /** + * The compressed size of the file + */ + size: number; + /** + * The original size of the file + */ + originalSize: number; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA. If the filter function returns true + * but this value is not 8, the unzip function will throw. + */ + compression: number; +} +/** + * A filter for files to be extracted during the unzipping process + * @param file The info for the current file being processed + * @returns Whether or not to extract the current file + */ +export type UnzipFileFilter = (file: UnzipFileInfo) => boolean; +/** + * Streaming file extraction from ZIP archives + */ +export interface UnzipFile { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The name of the file + */ + name: string; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA. If start() is called but there is no + * decompression stream available for this method, start() will throw. + */ + compression: number; + /** + * The compressed size of the file. Will not be present for archives created + * in a streaming fashion. + */ + size?: number; + /** + * The original size of the file. Will not be present for archives created + * in a streaming fashion. + */ + originalSize?: number; + /** + * Starts reading from the stream. Calling this function will always enable + * this stream, but ocassionally the stream will be enabled even without + * this being called. + */ + start(): void; + /** + * A method to terminate any internal workers used by the stream. ondata + * will not be called any further. + */ + terminate: AsyncTerminable; +} +/** + * Streaming pass-through decompression for ZIP archives + */ +export declare class UnzipPassThrough implements UnzipDecoder { + static compression: number; + ondata: AsyncFlateStreamHandler; + push(chunk: Uint8Array, final: boolean): void; +} +/** + * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for + * better performance. + */ +export declare class UnzipInflate implements UnzipDecoder { + static compression: number; + private i; + ondata: AsyncFlateStreamHandler; + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + constructor(); + push(chunk: Uint8Array, final: boolean): void; +} +/** + * Asynchronous streaming DEFLATE decompression for ZIP archives + */ +export declare class AsyncUnzipInflate implements UnzipDecoder { + static compression: number; + private i; + ondata: AsyncFlateStreamHandler; + terminate: AsyncTerminable; + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + constructor(_: string, sz?: number); + push(chunk: Uint8Array, final: boolean): void; +} +/** + * A ZIP archive decompression stream that emits files as they are discovered + */ +export declare class Unzip { + private d; + private c; + private p; + private k; + private o; + /** + * Creates a ZIP decompression stream + * @param cb The callback to call whenever a file in the ZIP archive is found + */ + constructor(cb?: UnzipFileHandler); + /** + * Pushes a chunk to be unzipped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Registers a decoder with the stream, allowing for files compressed with + * the compression type provided to be expanded correctly + * @param decoder The decoder constructor + */ + register(decoder: UnzipDecoderConstructor): void; + /** + * The handler to call whenever a file is discovered + */ + onfile: UnzipFileHandler; +} +/** + * Asynchronously decompresses a ZIP archive + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @param cb The callback to call with the decompressed files + * @returns A function that can be used to immediately terminate the unzipping + */ +export declare function unzip(data: Uint8Array, opts: AsyncUnzipOptions, cb: UnzipCallback): AsyncTerminable; +/** + * Asynchronously decompresses a ZIP archive + * @param data The raw compressed ZIP file + * @param cb The callback to call with the decompressed files + * @returns A function that can be used to immediately terminate the unzipping + */ +export declare function unzip(data: Uint8Array, cb: UnzipCallback): AsyncTerminable; +/** + * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better + * performance with more than one file. + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @returns The decompressed files + */ +export declare function unzipSync(data: Uint8Array, opts?: UnzipOptions): Unzipped; diff --git a/tools/ui/node_modules/fflate/lib/node-worker.cjs b/tools/ui/node_modules/fflate/lib/node-worker.cjs new file mode 100644 index 0000000000000000000000000000000000000000..6546f8e8d7aa05fd379331631cbba0271764952c --- /dev/null +++ b/tools/ui/node_modules/fflate/lib/node-worker.cjs @@ -0,0 +1,36 @@ +"use strict"; +var _a; +// Mediocre shim +var Worker; +var isMarkedAsUntransferable; +var workerAdd = ";var __w=require('worker_threads');__w.parentPort.on('message',function(m){onmessage({data:m})}),postMessage=function(m,t){__w.parentPort.postMessage(m,t)},close=process.exit;self=global"; +try { + (_a = require('worker_threads'), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable); +} +catch (e) { +} +exports.default = Worker ? function (c, _, msg, transfer, cb) { + var done = false; + var w = new Worker(c + workerAdd, { eval: true }) + .on('error', function (e) { return cb(e, null); }) + .on('message', function (m) { return cb(null, m); }) + .on('exit', function (c) { + if (c && !done) + cb(new Error('exited with code ' + c), null); + }); + if (isMarkedAsUntransferable) + transfer = transfer.filter(function (t) { return !isMarkedAsUntransferable(t); }); + w.postMessage(msg, transfer); + w.terminate = function () { + done = true; + return Worker.prototype.terminate.call(w); + }; + return w; +} : function (_, __, ___, ____, cb) { + setImmediate(function () { return cb(new Error('async operations unsupported - update to Node 12+ (or Node 10-11 with the --experimental-worker CLI flag)'), null); }); + var NOP = function () { }; + return { + terminate: NOP, + postMessage: NOP + }; +}; diff --git a/tools/ui/node_modules/fflate/lib/node.cjs b/tools/ui/node_modules/fflate/lib/node.cjs new file mode 100644 index 0000000000000000000000000000000000000000..2af184ee06114ac0939176ed868915d2d48a903a --- /dev/null +++ b/tools/ui/node_modules/fflate/lib/node.cjs @@ -0,0 +1,2733 @@ +"use strict"; +// DEFLATE is a complex format; to read this code, you should probably check the RFC first: +// https://tools.ietf.org/html/rfc1951 +// You may also wish to take a look at the guide I made about this program: +// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad +exports.deflate = deflate; +exports.deflateSync = deflateSync; +exports.inflate = inflate; +exports.inflateSync = inflateSync; +exports.gzip = gzip; +exports.compress = gzip; +exports.gzipSync = gzipSync; +exports.compressSync = gzipSync; +exports.gunzip = gunzip; +exports.gunzipSync = gunzipSync; +exports.zlib = zlib; +exports.zlibSync = zlibSync; +exports.unzlib = unzlib; +exports.unzlibSync = unzlibSync; +exports.gzip = gzip; +exports.compress = gzip; +exports.decompress = decompress; +exports.decompressSync = decompressSync; +exports.strToU8 = strToU8; +exports.strFromU8 = strFromU8; +exports.zip = zip; +exports.zipSync = zipSync; +exports.unzip = unzip; +exports.unzipSync = unzipSync; +// Some of the following code is similar to that of UZIP.js: +// https://github.com/photopea/UZIP.js +// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size. +// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint +// is better for memory in most engines (I *think*). +var _a; +// Mediocre shim +var Worker; +var isMarkedAsUntransferable; +var workerAdd = ";var __w=require('worker_threads');__w.parentPort.on('message',function(m){onmessage({data:m})}),postMessage=function(m,t){__w.parentPort.postMessage(m,t)},close=process.exit;self=global"; +try { + (_a = require('worker_threads'), Worker = _a.Worker, isMarkedAsUntransferable = _a.isMarkedAsUntransferable); +} +catch (e) { +} +var node_worker_1 = {}; +node_worker_1["default"] = Worker ? function (c, _, msg, transfer, cb) { + var done = false; + var w = new Worker(c + workerAdd, { eval: true }) + .on('error', function (e) { return cb(e, null); }) + .on('message', function (m) { return cb(null, m); }) + .on('exit', function (c) { + if (c && !done) + cb(new Error('exited with code ' + c), null); + }); + if (isMarkedAsUntransferable) + transfer = transfer.filter(function (t) { return !isMarkedAsUntransferable(t); }); + w.postMessage(msg, transfer); + w.terminate = function () { + done = true; + return Worker.prototype.terminate.call(w); + }; + return w; +} : function (_, __, ___, ____, cb) { + setImmediate(function () { return cb(new Error('async operations unsupported - update to Node 12+ (or Node 10-11 with the --experimental-worker CLI flag)'), null); }); + var NOP = function () { }; + return { + terminate: NOP, + postMessage: NOP + }; +}; + +// aliases for shorter compressed code (most minifers don't do this) +var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array; +// fixed length extra bits +var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]); +// fixed distance extra bits +var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]); +// code length index map +var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]); +// get base, reverse index map from extra bits +var freb = function (eb, start) { + var b = new u16(31); + for (var i = 0; i < 31; ++i) { + b[i] = start += 1 << eb[i - 1]; + } + // numbers here are at max 18 bits + var r = new i32(b[30]); + for (var i = 1; i < 30; ++i) { + for (var j = b[i]; j < b[i + 1]; ++j) { + r[j] = ((j - b[i]) << 5) | i; + } + } + return { b: b, r: r }; +}; +var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r; +// we can ignore the fact that the other numbers are wrong; they never happen anyway +fl[28] = 258, revfl[258] = 28; +var _b = freb(fdeb, 0), fd = _b.b, revfd = _b.r; +// map of value to reverse (assuming 16 bits) +var rev = new u16(32768); +for (var i = 0; i < 32768; ++i) { + // reverse table algorithm from SO + var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1); + x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2); + x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4); + rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1; +} +// create huffman tree from u8 "map": index -> code length for code index +// mb (max bits) must be at most 15 +// TODO: optimize/split up? +var hMap = (function (cd, mb, r) { + var s = cd.length; + // index + var i = 0; + // u16 "map": index -> # of codes with bit length = index + var l = new u16(mb); + // length of cd must be 288 (total # of codes) + for (; i < s; ++i) { + if (cd[i]) + ++l[cd[i] - 1]; + } + // u16 "map": index -> minimum code for bit length = index + var le = new u16(mb); + for (i = 1; i < mb; ++i) { + le[i] = (le[i - 1] + l[i - 1]) << 1; + } + var co; + if (r) { + // u16 "map": index -> number of actual bits, symbol for code + co = new u16(1 << mb); + // bits to remove for reverser + var rvb = 15 - mb; + for (i = 0; i < s; ++i) { + // ignore 0 lengths + if (cd[i]) { + // num encoding both symbol and bits read + var sv = (i << 4) | cd[i]; + // free bits + var r_1 = mb - cd[i]; + // start value + var v = le[cd[i] - 1]++ << r_1; + // m is end value + for (var m = v | ((1 << r_1) - 1); v <= m; ++v) { + // every 16 bit value starting with the code yields the same result + co[rev[v] >> rvb] = sv; + } + } + } + } + else { + co = new u16(s); + for (i = 0; i < s; ++i) { + if (cd[i]) { + co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]); + } + } + } + return co; +}); +// fixed length tree +var flt = new u8(288); +for (var i = 0; i < 144; ++i) + flt[i] = 8; +for (var i = 144; i < 256; ++i) + flt[i] = 9; +for (var i = 256; i < 280; ++i) + flt[i] = 7; +for (var i = 280; i < 288; ++i) + flt[i] = 8; +// fixed distance tree +var fdt = new u8(32); +for (var i = 0; i < 32; ++i) + fdt[i] = 5; +// fixed length map +var flm = /*#__PURE__*/ hMap(flt, 9, 0), flrm = /*#__PURE__*/ hMap(flt, 9, 1); +// fixed distance map +var fdm = /*#__PURE__*/ hMap(fdt, 5, 0), fdrm = /*#__PURE__*/ hMap(fdt, 5, 1); +// find max of array +var max = function (a) { + var m = a[0]; + for (var i = 1; i < a.length; ++i) { + if (a[i] > m) + m = a[i]; + } + return m; +}; +// read d, starting at bit p and mask with m +var bits = function (d, p, m) { + var o = (p / 8) | 0; + return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m; +}; +// read d, starting at bit p continuing for at least 16 bits +var bits16 = function (d, p) { + var o = (p / 8) | 0; + return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7)); +}; +// get end of byte +var shft = function (p) { return ((p + 7) / 8) | 0; }; +// typed array slice - allows garbage collector to free original reference, +// while being more compatible than .slice +var slc = function (v, s, e) { + if (s == null || s < 0) + s = 0; + if (e == null || e > v.length) + e = v.length; + // can't use .constructor in case user-supplied + return new u8(v.subarray(s, e)); +}; +/** + * Codes for errors generated within this library + */ +exports.FlateErrorCode = { + UnexpectedEOF: 0, + InvalidBlockType: 1, + InvalidLengthLiteral: 2, + InvalidDistance: 3, + StreamFinished: 4, + NoStreamHandler: 5, + InvalidHeader: 6, + NoCallback: 7, + InvalidUTF8: 8, + ExtraFieldTooLong: 9, + InvalidDate: 10, + FilenameTooLong: 11, + StreamFinishing: 12, + InvalidZipData: 13, + UnknownCompressionMethod: 14 +}; +// error codes +var ec = [ + 'unexpected EOF', + 'invalid block type', + 'invalid length/literal', + 'invalid distance', + 'stream finished', + 'no stream handler', + , // determined by compression function + 'no callback', + 'invalid UTF-8 data', + 'extra field too long', + 'date not in range 1980-2099', + 'filename too long', + 'stream finishing', + 'invalid zip data' + // determined by unknown compression method +]; +; +var err = function (ind, msg, nt) { + var e = new Error(msg || ec[ind]); + e.code = ind; + if (Error.captureStackTrace) + Error.captureStackTrace(e, err); + if (!nt) + throw e; + return e; +}; +// expands raw DEFLATE data +var inflt = function (dat, st, buf, dict) { + // source length dict length + var sl = dat.length, dl = dict ? dict.length : 0; + if (!sl || st.f && !st.l) + return buf || new u8(0); + var noBuf = !buf; + // have to estimate size + var resize = noBuf || st.i != 2; + // no state + var noSt = st.i; + // Assumes roughly 33% compression ratio average + if (noBuf) + buf = new u8(sl * 3); + // ensure buffer can fit at least l elements + var cbuf = function (l) { + var bl = buf.length; + // need to increase size to fit + if (l > bl) { + // Double or set to necessary, whichever is greater + var nbuf = new u8(Math.max(bl * 2, l)); + nbuf.set(buf); + buf = nbuf; + } + }; + // last chunk bitpos bytes + var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n; + // total bits + var tbts = sl * 8; + do { + if (!lm) { + // BFINAL - this is only 1 when last chunk is next + final = bits(dat, pos, 1); + // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman + var type = bits(dat, pos + 1, 3); + pos += 3; + if (!type) { + // go to end of byte boundary + var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l; + if (t > sl) { + if (noSt) + err(0); + break; + } + // ensure size + if (resize) + cbuf(bt + l); + // Copy over uncompressed data + buf.set(dat.subarray(s, t), bt); + // Get new bitpos, update byte count + st.b = bt += l, st.p = pos = t * 8, st.f = final; + continue; + } + else if (type == 1) + lm = flrm, dm = fdrm, lbt = 9, dbt = 5; + else if (type == 2) { + // literal lengths + var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4; + var tl = hLit + bits(dat, pos + 5, 31) + 1; + pos += 14; + // length+distance tree + var ldt = new u8(tl); + // code length tree + var clt = new u8(19); + for (var i = 0; i < hcLen; ++i) { + // use index map to get real code + clt[clim[i]] = bits(dat, pos + i * 3, 7); + } + pos += hcLen * 3; + // code lengths bits + var clb = max(clt), clbmsk = (1 << clb) - 1; + // code lengths map + var clm = hMap(clt, clb, 1); + for (var i = 0; i < tl;) { + var r = clm[bits(dat, pos, clbmsk)]; + // bits read + pos += r & 15; + // symbol + var s = r >> 4; + // code length to copy + if (s < 16) { + ldt[i++] = s; + } + else { + // copy count + var c = 0, n = 0; + if (s == 16) + n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1]; + else if (s == 17) + n = 3 + bits(dat, pos, 7), pos += 3; + else if (s == 18) + n = 11 + bits(dat, pos, 127), pos += 7; + while (n--) + ldt[i++] = c; + } + } + // length tree distance tree + var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit); + // max length bits + lbt = max(lt); + // max dist bits + dbt = max(dt); + lm = hMap(lt, lbt, 1); + dm = hMap(dt, dbt, 1); + } + else + err(1); + if (pos > tbts) { + if (noSt) + err(0); + break; + } + } + // Make sure the buffer can hold this + the largest possible addition + // Maximum chunk size (practically, theoretically infinite) is 2^17 + if (resize) + cbuf(bt + 131072); + var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1; + var lpos = pos; + for (;; lpos = pos) { + // bits read, code + var c = lm[bits16(dat, pos) & lms], sym = c >> 4; + pos += c & 15; + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (!c) + err(2); + if (sym < 256) + buf[bt++] = sym; + else if (sym == 256) { + lpos = pos, lm = null; + break; + } + else { + var add = sym - 254; + // no extra bits needed if less + if (sym > 264) { + // index + var i = sym - 257, b = fleb[i]; + add = bits(dat, pos, (1 << b) - 1) + fl[i]; + pos += b; + } + // dist + var d = dm[bits16(dat, pos) & dms], dsym = d >> 4; + if (!d) + err(3); + pos += d & 15; + var dt = fd[dsym]; + if (dsym > 3) { + var b = fdeb[dsym]; + dt += bits16(dat, pos) & (1 << b) - 1, pos += b; + } + if (pos > tbts) { + if (noSt) + err(0); + break; + } + if (resize) + cbuf(bt + 131072); + var end = bt + add; + if (bt < dt) { + var shift = dl - dt, dend = Math.min(dt, end); + if (shift + bt < 0) + err(3); + for (; bt < dend; ++bt) + buf[bt] = dict[shift + bt]; + } + for (; bt < end; ++bt) + buf[bt] = buf[bt - dt]; + } + } + st.l = lm, st.p = lpos, st.b = bt, st.f = final; + if (lm) + final = 1, st.m = lbt, st.d = dm, st.n = dbt; + } while (!final); + // don't reallocate for streams or user buffers + return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt); +}; +// starting at p, write the minimum number of bits that can hold v to d +var wbits = function (d, p, v) { + v <<= p & 7; + var o = (p / 8) | 0; + d[o] |= v; + d[o + 1] |= v >> 8; +}; +// starting at p, write the minimum number of bits (>8) that can hold v to d +var wbits16 = function (d, p, v) { + v <<= p & 7; + var o = (p / 8) | 0; + d[o] |= v; + d[o + 1] |= v >> 8; + d[o + 2] |= v >> 16; +}; +// creates code lengths from a frequency table +var hTree = function (d, mb) { + // Need extra info to make a tree + var t = []; + for (var i = 0; i < d.length; ++i) { + if (d[i]) + t.push({ s: i, f: d[i] }); + } + var s = t.length; + var t2 = t.slice(); + if (!s) + return { t: et, l: 0 }; + if (s == 1) { + var v = new u8(t[0].s + 1); + v[t[0].s] = 1; + return { t: v, l: 1 }; + } + t.sort(function (a, b) { return a.f - b.f; }); + // after i2 reaches last ind, will be stopped + // freq must be greater than largest possible number of symbols + t.push({ s: -1, f: 25001 }); + var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2; + t[0] = { s: -1, f: l.f + r.f, l: l, r: r }; + // efficient algorithm from UZIP.js + // i0 is lookbehind, i2 is lookahead - after processing two low-freq + // symbols that combined have high freq, will start processing i2 (high-freq, + // non-composite) symbols instead + // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/ + while (i1 != s - 1) { + l = t[t[i0].f < t[i2].f ? i0++ : i2++]; + r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++]; + t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r }; + } + var maxSym = t2[0].s; + for (var i = 1; i < s; ++i) { + if (t2[i].s > maxSym) + maxSym = t2[i].s; + } + // code lengths + var tr = new u16(maxSym + 1); + // max bits in tree + var mbt = ln(t[i1 - 1], tr, 0); + if (mbt > mb) { + // more algorithms from UZIP.js + // TODO: find out how this code works (debt) + // ind debt + var i = 0, dt = 0; + // left cost + var lft = mbt - mb, cst = 1 << lft; + t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; }); + for (; i < s; ++i) { + var i2_1 = t2[i].s; + if (tr[i2_1] > mb) { + dt += cst - (1 << (mbt - tr[i2_1])); + tr[i2_1] = mb; + } + else + break; + } + dt >>= lft; + while (dt > 0) { + var i2_2 = t2[i].s; + if (tr[i2_2] < mb) + dt -= 1 << (mb - tr[i2_2]++ - 1); + else + ++i; + } + for (; i >= 0 && dt; --i) { + var i2_3 = t2[i].s; + if (tr[i2_3] == mb) { + --tr[i2_3]; + ++dt; + } + } + mbt = mb; + } + return { t: new u8(tr), l: mbt }; +}; +// get the max length and assign length codes +var ln = function (n, l, d) { + return n.s == -1 + ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1)) + : (l[n.s] = d); +}; +// length codes generation +var lc = function (c) { + var s = c.length; + // Note that the semicolon was intentional + while (s && !c[--s]) + ; + var cl = new u16(++s); + // ind num streak + var cli = 0, cln = c[0], cls = 1; + var w = function (v) { cl[cli++] = v; }; + for (var i = 1; i <= s; ++i) { + if (c[i] == cln && i != s) + ++cls; + else { + if (!cln && cls > 2) { + for (; cls > 138; cls -= 138) + w(32754); + if (cls > 2) { + w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305); + cls = 0; + } + } + else if (cls > 3) { + w(cln), --cls; + for (; cls > 6; cls -= 6) + w(8304); + if (cls > 2) + w(((cls - 3) << 5) | 8208), cls = 0; + } + while (cls--) + w(cln); + cls = 1; + cln = c[i]; + } + } + return { c: cl.subarray(0, cli), n: s }; +}; +// calculate the length of output from tree, code lengths +var clen = function (cf, cl) { + var l = 0; + for (var i = 0; i < cl.length; ++i) + l += cf[i] * cl[i]; + return l; +}; +// writes a fixed block +// returns the new bit pos +var wfblk = function (out, pos, dat) { + // no need to write 00 as type: TypedArray defaults to 0 + var s = dat.length; + var o = shft(pos + 2); + out[o] = s & 255; + out[o + 1] = s >> 8; + out[o + 2] = out[o] ^ 255; + out[o + 3] = out[o + 1] ^ 255; + for (var i = 0; i < s; ++i) + out[o + i + 4] = dat[i]; + return (o + 4 + s) * 8; +}; +// writes a block +var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) { + wbits(out, p++, final); + ++lf[256]; + var _a = hTree(lf, 15), dlt = _a.t, mlb = _a.l; + var _b = hTree(df, 15), ddt = _b.t, mdb = _b.l; + var _c = lc(dlt), lclt = _c.c, nlc = _c.n; + var _d = lc(ddt), lcdt = _d.c, ndc = _d.n; + var lcfreq = new u16(19); + for (var i = 0; i < lclt.length; ++i) + ++lcfreq[lclt[i] & 31]; + for (var i = 0; i < lcdt.length; ++i) + ++lcfreq[lcdt[i] & 31]; + var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l; + var nlcc = 19; + for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc) + ; + var flen = (bl + 5) << 3; + var ftlen = clen(lf, flt) + clen(df, fdt) + eb; + var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]; + if (bs >= 0 && flen <= ftlen && flen <= dtlen) + return wfblk(out, p, dat.subarray(bs, bs + bl)); + var lm, ll, dm, dl; + wbits(out, p, 1 + (dtlen < ftlen)), p += 2; + if (dtlen < ftlen) { + lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt; + var llm = hMap(lct, mlcb, 0); + wbits(out, p, nlc - 257); + wbits(out, p + 5, ndc - 1); + wbits(out, p + 10, nlcc - 4); + p += 14; + for (var i = 0; i < nlcc; ++i) + wbits(out, p + 3 * i, lct[clim[i]]); + p += 3 * nlcc; + var lcts = [lclt, lcdt]; + for (var it = 0; it < 2; ++it) { + var clct = lcts[it]; + for (var i = 0; i < clct.length; ++i) { + var len = clct[i] & 31; + wbits(out, p, llm[len]), p += lct[len]; + if (len > 15) + wbits(out, p, (clct[i] >> 5) & 127), p += clct[i] >> 12; + } + } + } + else { + lm = flm, ll = flt, dm = fdm, dl = fdt; + } + for (var i = 0; i < li; ++i) { + var sym = syms[i]; + if (sym > 255) { + var len = (sym >> 18) & 31; + wbits16(out, p, lm[len + 257]), p += ll[len + 257]; + if (len > 7) + wbits(out, p, (sym >> 23) & 31), p += fleb[len]; + var dst = sym & 31; + wbits16(out, p, dm[dst]), p += dl[dst]; + if (dst > 3) + wbits16(out, p, (sym >> 5) & 8191), p += fdeb[dst]; + } + else { + wbits16(out, p, lm[sym]), p += ll[sym]; + } + } + wbits16(out, p, lm[256]); + return p + ll[256]; +}; +// deflate options (nice << 13) | chain +var deo = /*#__PURE__*/ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]); +// empty +var et = /*#__PURE__*/ new u8(0); +// compresses data into a raw DEFLATE buffer +var dflt = function (dat, lvl, plvl, pre, post, st) { + var s = st.z || dat.length; + var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post); + // writing to this writes to the output buffer + var w = o.subarray(pre, o.length - post); + var lst = st.l; + var pos = (st.r || 0) & 7; + if (lvl) { + if (pos) + w[0] = st.r >> 3; + var opt = deo[lvl - 1]; + var n = opt >> 13, c = opt & 8191; + var msk_1 = (1 << plvl) - 1; + // prev 2-byte val map curr 2-byte val map + var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1); + var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1; + var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; }; + // 24576 is an arbitrary number of maximum symbols per block + // 424 buffer for last block + var syms = new i32(25000); + // length/literal freq distance freq + var lf = new u16(288), df = new u16(32); + // l/lcnt exbits index l/lind waitdx blkpos + var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0; + for (; i + 2 < s; ++i) { + // hash value + var hv = hsh(i); + // index mod 32768 previous index mod + var imod = i & 32767, pimod = head[hv]; + prev[imod] = pimod; + head[hv] = imod; + // We always should modify head and prev, but only add symbols if + // this data is not yet processed ("wait" for wait index) + if (wi <= i) { + // bytes remaining + var rem = s - i; + if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) { + pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos); + li = lc_1 = eb = 0, bs = i; + for (var j = 0; j < 286; ++j) + lf[j] = 0; + for (var j = 0; j < 30; ++j) + df[j] = 0; + } + // len dist chain + var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767; + if (rem > 2 && hv == hsh(i - dif)) { + var maxn = Math.min(n, rem) - 1; + var maxd = Math.min(32767, i); + // max possible length + // not capped at dif because decompressors implement "rolling" index population + var ml = Math.min(258, rem); + while (dif <= maxd && --ch_1 && imod != pimod) { + if (dat[i + l] == dat[i + l - dif]) { + var nl = 0; + for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl) + ; + if (nl > l) { + l = nl, d = dif; + // break out early when we reach "nice" (we are satisfied enough) + if (nl > maxn) + break; + // now, find the rarest 2-byte sequence within this + // length of literals and search for that instead. + // Much faster than just using the start + var mmd = Math.min(dif, nl - 2); + var md = 0; + for (var j = 0; j < mmd; ++j) { + var ti = i - dif + j & 32767; + var pti = prev[ti]; + var cd = ti - pti & 32767; + if (cd > md) + md = cd, pimod = ti; + } + } + } + // check the previous match + imod = pimod, pimod = prev[imod]; + dif += imod - pimod & 32767; + } + } + // d will be nonzero only when a match was found + if (d) { + // store both dist and len data in one int32 + // Make sure this is recognized as a len/dist with 28th bit (2^28) + syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d]; + var lin = revfl[l] & 31, din = revfd[d] & 31; + eb += fleb[lin] + fdeb[din]; + ++lf[257 + lin]; + ++df[din]; + wi = i + l; + ++lc_1; + } + else { + syms[li++] = dat[i]; + ++lf[dat[i]]; + } + } + } + for (i = Math.max(i, wi); i < s; ++i) { + syms[li++] = dat[i]; + ++lf[dat[i]]; + } + pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos); + if (!lst) { + st.r = (pos & 7) | w[(pos / 8) | 0] << 3; + // shft(pos) now 1 less if pos & 7 != 0 + pos -= 7; + st.h = head, st.p = prev, st.i = i, st.w = wi; + } + } + else { + for (var i = st.w || 0; i < s + lst; i += 65535) { + // end + var e = i + 65535; + if (e >= s) { + // write final block + w[(pos / 8) | 0] = lst; + e = s; + } + pos = wfblk(w, pos + 1, dat.subarray(i, e)); + } + st.i = s; + } + return slc(o, 0, pre + shft(pos) + post); +}; +// CRC32 table +var crct = /*#__PURE__*/ (function () { + var t = new Int32Array(256); + for (var i = 0; i < 256; ++i) { + var c = i, k = 9; + while (--k) + c = ((c & 1) && -306674912) ^ (c >>> 1); + t[i] = c; + } + return t; +})(); +// CRC32 +var crc = function () { + var c = -1; + return { + p: function (d) { + // closures have awful performance + var cr = c; + for (var i = 0; i < d.length; ++i) + cr = crct[(cr & 255) ^ d[i]] ^ (cr >>> 8); + c = cr; + }, + d: function () { return ~c; } + }; +}; +// Adler32 +var adler = function () { + var a = 1, b = 0; + return { + p: function (d) { + // closures have awful performance + var n = a, m = b; + var l = d.length | 0; + for (var i = 0; i != l;) { + var e = Math.min(i + 2655, l); + for (; i < e; ++i) + m += n += d[i]; + n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16); + } + a = n, b = m; + }, + d: function () { + a %= 65521, b %= 65521; + return (a & 255) << 24 | (a & 0xFF00) << 8 | (b & 255) << 8 | (b >> 8); + } + }; +}; +; +// deflate with opts +var dopt = function (dat, opt, pre, post, st) { + if (!st) { + st = { l: 1 }; + if (opt.dictionary) { + var dict = opt.dictionary.subarray(-32768); + var newDat = new u8(dict.length + dat.length); + newDat.set(dict); + newDat.set(dat, dict.length); + dat = newDat; + st.w = dict.length; + } + } + return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? (st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20) : (12 + opt.mem), pre, post, st); +}; +// Walmart object spread +var mrg = function (a, b) { + var o = {}; + for (var k in a) + o[k] = a[k]; + for (var k in b) + o[k] = b[k]; + return o; +}; +// worker clone +// This is possibly the craziest part of the entire codebase, despite how simple it may seem. +// The only parameter to this function is a closure that returns an array of variables outside of the function scope. +// We're going to try to figure out the variable names used in the closure as strings because that is crucial for workerization. +// We will return an object mapping of true variable name to value (basically, the current scope as a JS object). +// The reason we can't just use the original variable names is minifiers mangling the toplevel scope. +// This took me three weeks to figure out how to do. +var wcln = function (fn, fnStr, td) { + var dt = fn(); + var st = fn.toString(); + var ks = st.slice(st.indexOf('[') + 1, st.lastIndexOf(']')).replace(/\s+/g, '').split(','); + for (var i = 0; i < dt.length; ++i) { + var v = dt[i], k = ks[i]; + if (typeof v == 'function') { + fnStr += ';' + k + '='; + var st_1 = v.toString(); + if (v.prototype) { + // for global objects + if (st_1.indexOf('[native code]') != -1) { + var spInd = st_1.indexOf(' ', 8) + 1; + fnStr += st_1.slice(spInd, st_1.indexOf('(', spInd)); + } + else { + fnStr += st_1; + for (var t in v.prototype) + fnStr += ';' + k + '.prototype.' + t + '=' + v.prototype[t].toString(); + } + } + else + fnStr += st_1; + } + else + td[k] = v; + } + return fnStr; +}; +var ch = []; +// clone bufs +var cbfs = function (v) { + var tl = []; + for (var k in v) { + if (v[k].buffer) { + tl.push((v[k] = new v[k].constructor(v[k])).buffer); + } + } + return tl; +}; +// use a worker to execute code +var wrkr = function (fns, init, id, cb) { + if (!ch[id]) { + var fnStr = '', td_1 = {}, m = fns.length - 1; + for (var i = 0; i < m; ++i) + fnStr = wcln(fns[i], fnStr, td_1); + ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 }; + } + var td = mrg({}, ch[id].e); + return (0, node_worker_1.default)(ch[id].c + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb); +}; +// base async inflate fn +var bInflt = function () { return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt]; }; +var bDflt = function () { return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; }; +// gzip extra +var gze = function () { return [gzh, gzhl, wbytes, crc, crct]; }; +// gunzip extra +var guze = function () { return [gzs, gzl]; }; +// zlib extra +var zle = function () { return [zlh, wbytes, adler]; }; +// unzlib extra +var zule = function () { return [zls]; }; +// post buf +var pbf = function (msg) { return postMessage(msg, [msg.buffer]); }; +// get opts +var gopt = function (o) { return o && { + out: o.size && new u8(o.size), + dictionary: o.dictionary +}; }; +// async helper +var cbify = function (dat, opts, fns, init, id, cb) { + var w = wrkr(fns, init, id, function (err, dat) { + w.terminate(); + cb(err, dat); + }); + w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []); + return function () { w.terminate(); }; +}; +// auto stream +var astrm = function (strm) { + strm.ondata = function (dat, final) { return postMessage([dat, final], [dat.buffer]); }; + return function (ev) { + if (ev.data[0]) { + strm.push(ev.data[0], ev.data[1]); + postMessage([ev.data[0].length]); + } + else + strm.flush(ev.data[1]); + }; +}; +// async stream attach +var astrmify = function (fns, strm, opts, init, id, flush, ext) { + var t; + var w = wrkr(fns, init, id, function (err, dat) { + if (err) + w.terminate(), strm.ondata.call(strm, err); + else if (!Array.isArray(dat)) + ext(dat); + else if (dat.length == 1) { + strm.queuedSize -= dat[0]; + if (strm.ondrain) + strm.ondrain(dat[0]); + } + else { + if (dat[1]) + w.terminate(); + strm.ondata.call(strm, err, dat[0], dat[1]); + } + }); + w.postMessage(opts); + strm.queuedSize = 0; + strm.push = function (d, f) { + if (!strm.ondata) + err(5); + if (t) + strm.ondata(err(4, 0, 1), null, !!f); + strm.queuedSize += d.length; + // can fail for cross-realm Uint8Array, but ok - only a small performance penalty + w.postMessage([d, t = f], d.buffer instanceof ArrayBuffer ? [d.buffer] : []); + }; + strm.terminate = function () { w.terminate(); }; + if (flush) { + strm.flush = function (sync) { w.postMessage([0, sync]); }; + } +}; +// read 2 bytes +var b2 = function (d, b) { return d[b] | (d[b + 1] << 8); }; +// read 4 bytes +var b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; }; +// read 8 bytes +var b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); }; +// write bytes +var wbytes = function (d, b, v) { + for (; v; ++b) + d[b] = v, v >>>= 8; +}; +// gzip header +var gzh = function (c, o) { + var fn = o.filename; + c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3; // assume Unix + if (o.mtime != 0) + wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1000)); + if (fn) { + c[3] = 8; + for (var i = 0; i <= fn.length; ++i) + c[i + 10] = fn.charCodeAt(i); + } +}; +// gzip footer: -8 to -4 = CRC, -4 to -0 is length +// gzip start +var gzs = function (d) { + if (d[0] != 31 || d[1] != 139 || d[2] != 8) + err(6, 'invalid gzip data'); + var flg = d[3]; + var st = 10; + if (flg & 4) + st += (d[10] | d[11] << 8) + 2; + for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++]) + ; + return st + (flg & 2); +}; +// gzip length +var gzl = function (d) { + var l = d.length; + return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0; +}; +// gzip header length +var gzhl = function (o) { return 10 + (o.filename ? o.filename.length + 1 : 0); }; +// zlib header +var zlh = function (c, o) { + var lv = o.level, fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2; + c[0] = 120, c[1] = (fl << 6) | (o.dictionary && 32); + c[1] |= 31 - ((c[0] << 8) | c[1]) % 31; + if (o.dictionary) { + var h = adler(); + h.p(o.dictionary); + wbytes(c, 2, h.d()); + } +}; +// zlib start +var zls = function (d, dict) { + if ((d[0] & 15) != 8 || (d[0] >> 4) > 7 || ((d[0] << 8 | d[1]) % 31)) + err(6, 'invalid zlib data'); + if ((d[1] >> 5 & 1) == +!dict) + err(6, 'invalid zlib data: ' + (d[1] & 32 ? 'need' : 'unexpected') + ' dictionary'); + return (d[1] >> 3 & 4) + 2; +}; +function StrmOpt(opts, cb) { + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + return opts; +} +/** + * Streaming DEFLATE compression + */ +var Deflate = /*#__PURE__*/ (function () { + function Deflate(opts, cb) { + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + this.o = opts || {}; + this.s = { l: 0, i: 32768, w: 32768, z: 32768 }; + // Buffer length must always be 0 mod 32768 for index calculations to be correct when modifying head and prev + // 98304 = 32768 (lookback) + 65536 (common chunk size) + this.b = new u8(98304); + if (this.o.dictionary) { + var dict = this.o.dictionary.subarray(-32768); + this.b.set(dict, 32768 - dict.length); + this.s.i = 32768 - dict.length; + } + } + Deflate.prototype.p = function (c, f) { + this.ondata(dopt(c, this.o, 0, 0, this.s), f); + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Deflate.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (this.s.l) + err(4); + var endLen = chunk.length + this.s.z; + if (endLen > this.b.length) { + if (endLen > 2 * this.b.length - 32768) { + var newBuf = new u8(endLen & -32768); + newBuf.set(this.b.subarray(0, this.s.z)); + this.b = newBuf; + } + var split = this.b.length - this.s.z; + this.b.set(chunk.subarray(0, split), this.s.z); + this.s.z = this.b.length; + this.p(this.b, false); + this.b.set(this.b.subarray(-32768)); + this.b.set(chunk.subarray(split), 32768); + this.s.z = chunk.length - split + 32768; + this.s.i = 32766, this.s.w = 32768; + } + else { + this.b.set(chunk, this.s.z); + this.s.z += chunk.length; + } + this.s.l = final & 1; + if (this.s.z > this.s.w + 8191 || final) { + this.p(this.b, final || false); + this.s.w = this.s.i, this.s.i -= 2; + } + if (final) { + // cleanup unneeded buffers/state to reduce memory usage + this.s = this.o = {}; + this.b = et; + } + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + Deflate.prototype.flush = function (sync) { + if (!this.ondata) + err(5); + if (this.s.l) + err(4); + this.p(this.b, false); + this.s.w = this.s.i, this.s.i -= 2; + // could technically skip writing the type-0 block for (this.s.r & 7) == 0, + // but the deterministic trailer (00 00 FF FF) is useful in some situations + if (sync) { + var c = new u8(6); + c[0] = this.s.r >> 3; + // write empty, non-final type-0 block + var ep = wfblk(c, this.s.r, et); + this.s.r = 0; + this.ondata(c.subarray(0, ep >> 3), false); + } + }; + return Deflate; +}()); +exports.Deflate = Deflate; +/** + * Asynchronous streaming DEFLATE compression + */ +var AsyncDeflate = /*#__PURE__*/ (function () { + function AsyncDeflate(opts, cb) { + astrmify([ + bDflt, + function () { return [astrm, Deflate]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Deflate(ev.data); + onmessage = astrm(strm); + }, 6, 1); + } + return AsyncDeflate; +}()); +exports.AsyncDeflate = AsyncDeflate; +function deflate(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + ], function (ev) { return pbf(deflateSync(ev.data[0], ev.data[1])); }, 0, cb); +} +/** + * Compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @returns The deflated version of the data + */ +function deflateSync(data, opts) { + return dopt(data, opts || {}, 0, 0); +} +/** + * Streaming DEFLATE decompression + */ +var Inflate = /*#__PURE__*/ (function () { + function Inflate(opts, cb) { + // no StrmOpt here to avoid adding to workerizer + if (typeof opts == 'function') + cb = opts, opts = {}; + this.ondata = cb; + var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768); + this.s = { i: 0, b: dict ? dict.length : 0 }; + this.o = new u8(32768); + this.p = new u8(0); + if (dict) + this.o.set(dict); + } + Inflate.prototype.e = function (c) { + if (!this.ondata) + err(5); + if (this.d) + err(4); + if (!this.p.length) + this.p = c; + else if (c.length) { + var n = new u8(this.p.length + c.length); + n.set(this.p), n.set(c, this.p.length), this.p = n; + } + }; + Inflate.prototype.c = function (final) { + this.s.i = +(this.d = final || false); + var bts = this.s.b; + var dt = inflt(this.p, this.s, this.o); + this.ondata(slc(dt, bts, this.s.b), this.d); + this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length; + this.p = slc(this.p, (this.s.p / 8) | 0), this.s.p &= 7; + }; + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the final chunk + */ + Inflate.prototype.push = function (chunk, final) { + this.e(chunk), this.c(final); + }; + return Inflate; +}()); +exports.Inflate = Inflate; +/** + * Asynchronous streaming DEFLATE decompression + */ +var AsyncInflate = /*#__PURE__*/ (function () { + function AsyncInflate(opts, cb) { + astrmify([ + bInflt, + function () { return [astrm, Inflate]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Inflate(ev.data); + onmessage = astrm(strm); + }, 7, 0); + } + return AsyncInflate; +}()); +exports.AsyncInflate = AsyncInflate; +function inflate(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt + ], function (ev) { return pbf(inflateSync(ev.data[0], gopt(ev.data[1]))); }, 1, cb); +} +function inflateSync(data, opts) { + return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary); +} +// before you yell at me for not just using extends, my reason is that TS inheritance is hard to workerize. +/** + * Streaming GZIP compression + */ +var Gzip = /*#__PURE__*/ (function () { + function Gzip(opts, cb) { + this.c = crc(); + this.l = 0; + this.v = 1; + Deflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Gzip.prototype.push = function (chunk, final) { + this.c.p(chunk); + this.l += chunk.length; + Deflate.prototype.push.call(this, chunk, final); + }; + Gzip.prototype.p = function (c, f) { + var raw = dopt(c, this.o, this.v && gzhl(this.o), f && 8, this.s); + if (this.v) + gzh(raw, this.o), this.v = 0; + if (f) + wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l); + this.ondata(raw, f); + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + Gzip.prototype.flush = function (sync) { + Deflate.prototype.flush.call(this, sync); + }; + return Gzip; +}()); +exports.Gzip = Gzip; +exports.Compress = Gzip; +/** + * Asynchronous streaming GZIP compression + */ +var AsyncGzip = /*#__PURE__*/ (function () { + function AsyncGzip(opts, cb) { + astrmify([ + bDflt, + gze, + function () { return [astrm, Deflate, Gzip]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Gzip(ev.data); + onmessage = astrm(strm); + }, 8, 1); + } + return AsyncGzip; +}()); +exports.AsyncGzip = AsyncGzip; +exports.AsyncCompress = AsyncGzip; +function gzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + gze, + function () { return [gzipSync]; } + ], function (ev) { return pbf(gzipSync(ev.data[0], ev.data[1])); }, 2, cb); +} +/** + * Compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @returns The gzipped version of the data + */ +function gzipSync(data, opts) { + if (!opts) + opts = {}; + var c = crc(), l = data.length; + c.p(data); + var d = dopt(data, opts, gzhl(opts), 8), s = d.length; + return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d; +} +/** + * Streaming single or multi-member GZIP decompression + */ +var Gunzip = /*#__PURE__*/ (function () { + function Gunzip(opts, cb) { + this.v = 1; + this.r = 0; + Inflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Gunzip.prototype.push = function (chunk, final) { + Inflate.prototype.e.call(this, chunk); + this.r += chunk.length; + if (this.v) { + var p = this.p.subarray(this.v - 1); + var s = p.length > 3 ? gzs(p) : 4; + if (s > p.length) { + if (!final) + return; + } + else if (this.v > 1 && this.onmember) { + this.onmember(this.r - p.length); + } + this.p = p.subarray(s), this.v = 0; + } + // necessary to prevent TS from using the closure value + // This allows for workerization to function correctly + Inflate.prototype.c.call(this, 0); + // process concatenated GZIP + if (this.s.f && !this.s.l) { + this.v = shft(this.s.p) + 9; + this.s = { i: 0 }; + this.o = new u8(0); + this.push(new u8(0), final); + } + else if (final) { + Inflate.prototype.c.call(this, final); + } + }; + return Gunzip; +}()); +exports.Gunzip = Gunzip; +/** + * Asynchronous streaming single or multi-member GZIP decompression + */ +var AsyncGunzip = /*#__PURE__*/ (function () { + function AsyncGunzip(opts, cb) { + var _this = this; + astrmify([ + bInflt, + guze, + function () { return [astrm, Inflate, Gunzip]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Gunzip(ev.data); + strm.onmember = function (offset) { return postMessage(offset); }; + onmessage = astrm(strm); + }, 9, 0, function (offset) { return _this.onmember && _this.onmember(offset); }); + } + return AsyncGunzip; +}()); +exports.AsyncGunzip = AsyncGunzip; +function gunzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt, + guze, + function () { return [gunzipSync]; } + ], function (ev) { return pbf(gunzipSync(ev.data[0], ev.data[1])); }, 3, cb); +} +function gunzipSync(data, opts) { + var st = gzs(data); + if (st + 8 > data.length) + err(6, 'invalid gzip data'); + return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary); +} +/** + * Streaming Zlib compression + */ +var Zlib = /*#__PURE__*/ (function () { + function Zlib(opts, cb) { + this.c = adler(); + this.v = 1; + Deflate.call(this, opts, cb); + } + /** + * Pushes a chunk to be zlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Zlib.prototype.push = function (chunk, final) { + this.c.p(chunk); + Deflate.prototype.push.call(this, chunk, final); + }; + Zlib.prototype.p = function (c, f) { + var raw = dopt(c, this.o, this.v && (this.o.dictionary ? 6 : 2), f && 4, this.s); + if (this.v) + zlh(raw, this.o), this.v = 0; + if (f) + wbytes(raw, raw.length - 4, this.c.d()); + this.ondata(raw, f); + }; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + Zlib.prototype.flush = function (sync) { + Deflate.prototype.flush.call(this, sync); + }; + return Zlib; +}()); +exports.Zlib = Zlib; +/** + * Asynchronous streaming Zlib compression + */ +var AsyncZlib = /*#__PURE__*/ (function () { + function AsyncZlib(opts, cb) { + astrmify([ + bDflt, + zle, + function () { return [astrm, Deflate, Zlib]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Zlib(ev.data); + onmessage = astrm(strm); + }, 10, 1); + } + return AsyncZlib; +}()); +exports.AsyncZlib = AsyncZlib; +function zlib(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bDflt, + zle, + function () { return [zlibSync]; } + ], function (ev) { return pbf(zlibSync(ev.data[0], ev.data[1])); }, 4, cb); +} +/** + * Compress data with Zlib + * @param data The data to compress + * @param opts The compression options + * @returns The zlib-compressed version of the data + */ +function zlibSync(data, opts) { + if (!opts) + opts = {}; + var a = adler(); + a.p(data); + var d = dopt(data, opts, opts.dictionary ? 6 : 2, 4); + return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d; +} +/** + * Streaming Zlib decompression + */ +var Unzlib = /*#__PURE__*/ (function () { + function Unzlib(opts, cb) { + Inflate.call(this, opts, cb); + this.v = opts && opts.dictionary ? 2 : 1; + } + /** + * Pushes a chunk to be unzlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Unzlib.prototype.push = function (chunk, final) { + Inflate.prototype.e.call(this, chunk); + if (this.v) { + if (this.p.length < 6 && !final) + return; + this.p = this.p.subarray(zls(this.p, this.v - 1)), this.v = 0; + } + if (final) { + if (this.p.length < 4) + err(6, 'invalid zlib data'); + this.p = this.p.subarray(0, -4); + } + // necessary to prevent TS from using the closure value + // This allows for workerization to function correctly + Inflate.prototype.c.call(this, final); + }; + return Unzlib; +}()); +exports.Unzlib = Unzlib; +/** + * Asynchronous streaming Zlib decompression + */ +var AsyncUnzlib = /*#__PURE__*/ (function () { + function AsyncUnzlib(opts, cb) { + astrmify([ + bInflt, + zule, + function () { return [astrm, Inflate, Unzlib]; } + ], this, StrmOpt.call(this, opts, cb), function (ev) { + var strm = new Unzlib(ev.data); + onmessage = astrm(strm); + }, 11, 0); + } + return AsyncUnzlib; +}()); +exports.AsyncUnzlib = AsyncUnzlib; +function unzlib(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return cbify(data, opts, [ + bInflt, + zule, + function () { return [unzlibSync]; } + ], function (ev) { return pbf(unzlibSync(ev.data[0], gopt(ev.data[1]))); }, 5, cb); +} +function unzlibSync(data, opts) { + return inflt(data.subarray(zls(data, opts && opts.dictionary), -4), { i: 2 }, opts && opts.out, opts && opts.dictionary); +} +/** + * Streaming GZIP, Zlib, or raw DEFLATE decompression + */ +var Decompress = /*#__PURE__*/ (function () { + function Decompress(opts, cb) { + this.o = StrmOpt.call(this, opts, cb) || {}; + this.G = Gunzip; + this.I = Inflate; + this.Z = Unzlib; + } + // init substream + // overriden by AsyncDecompress + Decompress.prototype.i = function () { + var _this = this; + this.s.ondata = function (dat, final) { + _this.ondata(dat, final); + }; + }; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Decompress.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (!this.s) { + if (this.p && this.p.length) { + var n = new u8(this.p.length + chunk.length); + n.set(this.p), n.set(chunk, this.p.length); + } + else + this.p = chunk; + if (this.p.length > 2) { + this.s = (this.p[0] == 31 && this.p[1] == 139 && this.p[2] == 8) + ? new this.G(this.o) + : ((this.p[0] & 15) != 8 || (this.p[0] >> 4) > 7 || ((this.p[0] << 8 | this.p[1]) % 31)) + ? new this.I(this.o) + : new this.Z(this.o); + this.i(); + this.s.push(this.p, final); + this.p = null; + } + } + else + this.s.push(chunk, final); + }; + return Decompress; +}()); +exports.Decompress = Decompress; +/** + * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression + */ +var AsyncDecompress = /*#__PURE__*/ (function () { + function AsyncDecompress(opts, cb) { + Decompress.call(this, opts, cb); + this.queuedSize = 0; + this.G = AsyncGunzip; + this.I = AsyncInflate; + this.Z = AsyncUnzlib; + } + AsyncDecompress.prototype.i = function () { + var _this = this; + this.s.ondata = function (err, dat, final) { + _this.ondata(err, dat, final); + }; + this.s.ondrain = function (size) { + _this.queuedSize -= size; + if (_this.ondrain) + _this.ondrain(size); + }; + }; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + AsyncDecompress.prototype.push = function (chunk, final) { + this.queuedSize += chunk.length; + Decompress.prototype.push.call(this, chunk, final); + }; + return AsyncDecompress; +}()); +exports.AsyncDecompress = AsyncDecompress; +function decompress(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + return (data[0] == 31 && data[1] == 139 && data[2] == 8) + ? gunzip(data, opts, cb) + : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31)) + ? inflate(data, opts, cb) + : unzlib(data, opts, cb); +} +/** + * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +function decompressSync(data, opts) { + return (data[0] == 31 && data[1] == 139 && data[2] == 8) + ? gunzipSync(data, opts) + : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31)) + ? inflateSync(data, opts) + : unzlibSync(data, opts); +} +// flatten a directory structure +var fltn = function (d, p, t, o) { + for (var k in d) { + var val = d[k], n = p + k, op = o; + if (Array.isArray(val)) + op = mrg(o, val[1]), val = val[0]; + if (ArrayBuffer.isView(val)) + t[n] = [val, op]; + else { + t[n += '/'] = [new u8(0), op]; + fltn(val, n, t, o); + } + } +}; +// text encoder +var te = typeof TextEncoder != 'undefined' && /*#__PURE__*/ new TextEncoder(); +// text decoder +var td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder(); +// text decoder stream +var tds = 0; +try { + td.decode(et, { stream: true }); + tds = 1; +} +catch (e) { } +// decode UTF8 +var dutf8 = function (d) { + for (var r = '', i = 0;;) { + var c = d[i++]; + var eb = (c > 127) + (c > 223) + (c > 239); + if (i + eb > d.length) + return { s: r, r: slc(d, i - 1) }; + if (!eb) + r += String.fromCharCode(c); + else if (eb == 3) { + c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536, + r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023)); + } + else if (eb & 1) + r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63)); + else + r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)); + } +}; +/** + * Streaming UTF-8 decoding + */ +var DecodeUTF8 = /*#__PURE__*/ (function () { + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is decoded + */ + function DecodeUTF8(cb) { + this.ondata = cb; + if (tds) + this.t = new TextDecoder(); + else + this.p = et; + } + /** + * Pushes a chunk to be decoded from UTF-8 binary + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + DecodeUTF8.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + final = !!final; + if (this.t) { + this.ondata(this.t.decode(chunk, { stream: true }), final); + if (final) { + if (this.t.decode().length) + err(8); + this.t = null; + } + return; + } + if (!this.p) + err(4); + var dat = new u8(this.p.length + chunk.length); + dat.set(this.p); + dat.set(chunk, this.p.length); + var _a = dutf8(dat), s = _a.s, r = _a.r; + if (final) { + if (r.length) + err(8); + this.p = null; + } + else + this.p = r; + this.ondata(s, final); + }; + return DecodeUTF8; +}()); +exports.DecodeUTF8 = DecodeUTF8; +/** + * Streaming UTF-8 encoding + */ +var EncodeUTF8 = /*#__PURE__*/ (function () { + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is encoded + */ + function EncodeUTF8(cb) { + this.ondata = cb; + } + /** + * Pushes a chunk to be encoded to UTF-8 + * @param chunk The string data to push + * @param final Whether this is the last chunk + */ + EncodeUTF8.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + if (this.d) + err(4); + this.ondata(strToU8(chunk), this.d = final || false); + }; + return EncodeUTF8; +}()); +exports.EncodeUTF8 = EncodeUTF8; +/** + * Converts a string into a Uint8Array for use with compression/decompression methods + * @param str The string to encode + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless decoding a binary string. + * @returns The string encoded in UTF-8/Latin-1 binary + */ +function strToU8(str, latin1) { + if (latin1) { + var ar_1 = new u8(str.length); + for (var i = 0; i < str.length; ++i) + ar_1[i] = str.charCodeAt(i); + return ar_1; + } + if (te) + return te.encode(str); + var l = str.length; + var ar = new u8(str.length + (str.length >> 1)); + var ai = 0; + var w = function (v) { ar[ai++] = v; }; + for (var i = 0; i < l; ++i) { + if (ai + 5 > ar.length) { + var n = new u8(ai + 8 + ((l - i) << 1)); + n.set(ar); + ar = n; + } + var c = str.charCodeAt(i); + if (c < 128 || latin1) + w(c); + else if (c < 2048) + w(192 | (c >> 6)), w(128 | (c & 63)); + else if (c > 55295 && c < 57344) + c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023), + w(240 | (c >> 18)), w(128 | ((c >> 12) & 63)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63)); + else + w(224 | (c >> 12)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63)); + } + return slc(ar, 0, ai); +} +/** + * Converts a Uint8Array to a string + * @param dat The data to decode to string + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless encoding to binary string. + * @returns The original UTF-8/Latin-1 string + */ +function strFromU8(dat, latin1) { + if (latin1) { + var r = ''; + for (var i = 0; i < dat.length; i += 16384) + r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384)); + return r; + } + else if (td) { + return td.decode(dat); + } + else { + var _a = dutf8(dat), s = _a.s, r = _a.r; + if (r.length) + err(8); + return s; + } +} +; +// deflate bit flag +var dbf = function (l) { return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0; }; +// skip local zip header +var slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); }; +// read zip header +var zh = function (d, b, z) { + var fnl = b2(d, b + 28), efl = b2(d, b + 30), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl; + var _a = z64hs(d, es, efl, z, b4(d, b + 20), b4(d, b + 24), b4(d, b + 42)), sc = _a[0], su = _a[1], off = _a[2]; + return [b2(d, b + 10), sc, su, fn, es + efl + b2(d, b + 32), off]; +}; +// read zip64 header sizes +var z64hs = function (d, b, l, z, sc, su, off) { + var nsc = sc == 4294967295, nsu = su == 4294967295, noff = off == 4294967295, e = b + l; + var nf = nsc + nsu + noff; + if (z && nf) { + for (; b + 4 < e; b += 4 + b2(d, b + 2)) { + if (b2(d, b) == 1) { + return [ + nsc ? b8(d, b + 4 + 8 * nsu) : sc, + nsu ? b8(d, b + 4) : su, + noff ? b8(d, b + 4 + 8 * (nsu + nsc)) : off, + 1 + ]; + } + } + // z == 2 for unknown whether or not zip64 + if (z < 2) + err(13); + } + return [sc, su, off, 0]; +}; +// extra field length +var exfl = function (ex) { + var le = 0; + if (ex) { + for (var k in ex) { + var l = ex[k].length; + if (l > 65535) + err(9); + le += l + 4; + } + } + return le; +}; +// write zip header +var wzh = function (d, b, f, fn, u, c, ce, co) { + var fl = fn.length, ex = f.extra, col = co && co.length; + var exl = exfl(ex); + wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4; + if (ce != null) + d[b++] = 20, d[b++] = f.os; + d[b] = 20, b += 2; // spec compliance? what's that? + d[b++] = (f.flag << 1) | (c < 0 && 8), d[b++] = u && 8; + d[b++] = f.compression & 255, d[b++] = f.compression >> 8; + var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980; + if (y < 0 || y > 119) + err(10); + wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >> 1)), b += 4; + if (c != -1) { + wbytes(d, b, f.crc); + wbytes(d, b + 4, c < 0 ? -c - 2 : c); + wbytes(d, b + 8, f.size); + } + wbytes(d, b + 12, fl); + wbytes(d, b + 14, exl), b += 16; + if (ce != null) { + wbytes(d, b, col); + wbytes(d, b + 6, f.attrs); + wbytes(d, b + 10, ce), b += 14; + } + d.set(fn, b); + b += fl; + if (exl) { + for (var k in ex) { + var exf = ex[k], l = exf.length; + wbytes(d, b, +k); + wbytes(d, b + 2, l); + d.set(exf, b + 4), b += 4 + l; + } + } + if (col) + d.set(co, b), b += col; + return b; +}; +// write zip footer (end of central directory) +var wzf = function (o, b, c, d, e) { + wbytes(o, b, 0x6054B50); // skip disk + wbytes(o, b + 8, c); + wbytes(o, b + 10, c); + wbytes(o, b + 12, d); + wbytes(o, b + 16, e); +}; +/** + * A pass-through stream to keep data uncompressed in a ZIP archive. + */ +var ZipPassThrough = /*#__PURE__*/ (function () { + /** + * Creates a pass-through stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + */ + function ZipPassThrough(filename) { + this.filename = filename; + this.c = crc(); + this.size = 0; + this.compression = 0; + } + /** + * Processes a chunk and pushes to the output stream. You can override this + * method in a subclass for custom behavior, but by default this passes + * the data through. You must call this.ondata(err, chunk, final) at some + * point in this method. + * @param chunk The chunk to process + * @param final Whether this is the last chunk + */ + ZipPassThrough.prototype.process = function (chunk, final) { + this.ondata(null, chunk, final); + }; + /** + * Pushes a chunk to be added. If you are subclassing this with a custom + * compression algorithm, note that you must push data from the source + * file only, pre-compression. + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + ZipPassThrough.prototype.push = function (chunk, final) { + if (!this.ondata) + err(5); + this.c.p(chunk); + this.size += chunk.length; + if (final) + this.crc = this.c.d(); + // we shouldn't really do this cast, but properly handling ArrayBufferLike + // makes the API unergonomic with Buffer + this.process(chunk, final || false); + }; + return ZipPassThrough; +}()); +exports.ZipPassThrough = ZipPassThrough; +// I don't extend because TypeScript extension adds 1kB of runtime bloat +/** + * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate + * for better performance + */ +var ZipDeflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + function ZipDeflate(filename, opts) { + var _this = this; + if (!opts) + opts = {}; + ZipPassThrough.call(this, filename); + this.d = new Deflate(opts, function (dat, final) { + _this.ondata(null, dat, final); + }); + this.compression = 8; + this.flag = dbf(opts.level); + } + ZipDeflate.prototype.process = function (chunk, final) { + try { + this.d.push(chunk, final); + } + catch (e) { + this.ondata(e, null, final); + } + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + ZipDeflate.prototype.push = function (chunk, final) { + ZipPassThrough.prototype.push.call(this, chunk, final); + }; + return ZipDeflate; +}()); +exports.ZipDeflate = ZipDeflate; +/** + * Asynchronous streaming DEFLATE compression for ZIP archives + */ +var AsyncZipDeflate = /*#__PURE__*/ (function () { + /** + * Creates an asynchronous DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + function AsyncZipDeflate(filename, opts) { + var _this = this; + if (!opts) + opts = {}; + ZipPassThrough.call(this, filename); + this.d = new AsyncDeflate(opts, function (err, dat, final) { + _this.ondata(err, dat, final); + }); + this.compression = 8; + this.flag = dbf(opts.level); + this.terminate = this.d.terminate; + } + AsyncZipDeflate.prototype.process = function (chunk, final) { + this.d.push(chunk, final); + }; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + AsyncZipDeflate.prototype.push = function (chunk, final) { + ZipPassThrough.prototype.push.call(this, chunk, final); + }; + return AsyncZipDeflate; +}()); +exports.AsyncZipDeflate = AsyncZipDeflate; +// TODO: Better tree shaking +/** + * A zippable archive to which files can incrementally be added + */ +var Zip = /*#__PURE__*/ (function () { + /** + * Creates an empty ZIP archive to which files can be added + * @param cb The callback to call whenever data for the generated ZIP archive + * is available + */ + function Zip(cb) { + this.ondata = cb; + this.u = []; + this.d = 1; + } + /** + * Adds a file to the ZIP archive + * @param file The file stream to add + */ + Zip.prototype.add = function (file) { + var _this = this; + if (!this.ondata) + err(5); + // finishing or finished + if (this.d & 2) + this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, false); + else { + var f = strToU8(file.filename), fl_1 = f.length; + var com = file.comment, o = com && strToU8(com); + var u = fl_1 != file.filename.length || (o && (com.length != o.length)); + var hl_1 = fl_1 + exfl(file.extra) + 30; + if (fl_1 > 65535) + this.ondata(err(11, 0, 1), null, false); + var header = new u8(hl_1); + wzh(header, 0, file, f, u, -1); + var chks_1 = [header]; + var pAll_1 = function () { + for (var _i = 0, chks_2 = chks_1; _i < chks_2.length; _i++) { + var chk = chks_2[_i]; + _this.ondata(null, chk, false); + } + chks_1 = []; + }; + var tr_1 = this.d; + this.d = 0; + var ind_1 = this.u.length; + var uf_1 = mrg(file, { + f: f, + u: u, + o: o, + t: function () { + if (file.terminate) + file.terminate(); + }, + r: function () { + pAll_1(); + if (tr_1) { + var nxt = _this.u[ind_1 + 1]; + if (nxt) + nxt.r(); + else + _this.d = 1; + } + tr_1 = 1; + } + }); + var cl_1 = 0; + file.ondata = function (err, dat, final) { + if (err) { + _this.ondata(err, dat, final); + _this.terminate(); + } + else { + cl_1 += dat.length; + chks_1.push(dat); + if (final) { + var dd = new u8(16); + wbytes(dd, 0, 0x8074B50); + wbytes(dd, 4, file.crc); + wbytes(dd, 8, cl_1); + wbytes(dd, 12, file.size); + chks_1.push(dd); + uf_1.c = cl_1, uf_1.b = hl_1 + cl_1 + 16, uf_1.crc = file.crc, uf_1.size = file.size; + if (tr_1) + uf_1.r(); + tr_1 = 1; + } + else if (tr_1) + pAll_1(); + } + }; + this.u.push(uf_1); + } + }; + /** + * Ends the process of adding files and prepares to emit the final chunks. + * This *must* be called after adding all desired files for the resulting + * ZIP file to work properly. + */ + Zip.prototype.end = function () { + var _this = this; + if (this.d & 2) { + this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, true); + return; + } + if (this.d) + this.e(); + else + this.u.push({ + r: function () { + if (!(_this.d & 1)) + return; + _this.u.splice(-1, 1); + _this.e(); + }, + t: function () { } + }); + this.d = 3; + }; + Zip.prototype.e = function () { + var bt = 0, l = 0, tl = 0; + for (var _i = 0, _a = this.u; _i < _a.length; _i++) { + var f = _a[_i]; + tl += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0); + } + var out = new u8(tl + 22); + for (var _b = 0, _c = this.u; _b < _c.length; _b++) { + var f = _c[_b]; + wzh(out, bt, f, f.f, f.u, -f.c - 2, l, f.o); + bt += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0), l += f.b; + } + wzf(out, bt, this.u.length, tl, l); + this.ondata(null, out, true); + this.d = 2; + }; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to add() will fail. + */ + Zip.prototype.terminate = function () { + for (var _i = 0, _a = this.u; _i < _a.length; _i++) { + var f = _a[_i]; + f.t(); + } + this.d = 2; + }; + return Zip; +}()); +exports.Zip = Zip; +function zip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + var r = {}; + fltn(data, '', r, opts); + var k = Object.keys(r); + var lft = k.length, o = 0, tot = 0; + var slft = lft, files = new Array(lft); + var term = []; + var tAll = function () { + for (var i = 0; i < term.length; ++i) + term[i](); + }; + var cbd = function (a, b) { + mt(function () { cb(a, b); }); + }; + mt(function () { cbd = cb; }); + var cbf = function () { + var out = new u8(tot + 22), oe = o, cdl = tot - o; + tot = 0; + for (var i = 0; i < slft; ++i) { + var f = files[i]; + try { + var l = f.c.length; + wzh(out, tot, f, f.f, f.u, l); + var badd = 30 + f.f.length + exfl(f.extra); + var loc = tot + badd; + out.set(f.c, loc); + wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l; + } + catch (e) { + return cbd(e, null); + } + } + wzf(out, o, files.length, cdl, oe); + cbd(null, out); + }; + if (!lft) + cbf(); + var _loop_1 = function (i) { + var fn = k[i]; + var _a = r[fn], file = _a[0], p = _a[1]; + var c = crc(), size = file.length; + c.p(file); + var f = strToU8(fn), s = f.length; + var com = p.comment, m = com && strToU8(com), ms = m && m.length; + var exl = exfl(p.extra); + var compression = p.level == 0 ? 0 : 8; + var cbl = function (e, d) { + if (e) { + tAll(); + cbd(e, null); + } + else { + var l = d.length; + files[i] = mrg(p, { + size: size, + crc: c.d(), + c: d, + f: f, + m: m, + u: s != fn.length || (m && (com.length != ms)), + compression: compression + }); + o += 30 + s + exl + l; + tot += 76 + 2 * (s + exl) + (ms || 0) + l; + if (!--lft) + cbf(); + } + }; + if (s > 65535) + cbl(err(11, 0, 1), null); + if (!compression) + cbl(null, file); + else if (size < 160000) { + try { + cbl(null, deflateSync(file, p)); + } + catch (e) { + cbl(e, null); + } + } + else + term.push(deflate(file, p, cbl)); + }; + // Cannot use lft because it can decrease + for (var i = 0; i < slft; ++i) { + _loop_1(i); + } + return tAll; +} +/** + * Synchronously creates a ZIP file. Prefer using `zip` for better performance + * with more than one file. + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @returns The generated ZIP archive + */ +function zipSync(data, opts) { + if (!opts) + opts = {}; + var r = {}; + var files = []; + fltn(data, '', r, opts); + var o = 0; + var tot = 0; + for (var fn in r) { + var _a = r[fn], file = _a[0], p = _a[1]; + var compression = p.level == 0 ? 0 : 8; + var f = strToU8(fn), s = f.length; + var com = p.comment, m = com && strToU8(com), ms = m && m.length; + var exl = exfl(p.extra); + if (s > 65535) + err(11); + var d = compression ? deflateSync(file, p) : file, l = d.length; + var c = crc(); + c.p(file); + files.push(mrg(p, { + size: file.length, + crc: c.d(), + c: d, + f: f, + m: m, + u: s != fn.length || (m && (com.length != ms)), + o: o, + compression: compression + })); + o += 30 + s + exl + l; + tot += 76 + 2 * (s + exl) + (ms || 0) + l; + } + var out = new u8(tot + 22), oe = o, cdl = tot - o; + for (var i = 0; i < files.length; ++i) { + var f = files[i]; + wzh(out, f.o, f, f.f, f.u, f.c.length); + var badd = 30 + f.f.length + exfl(f.extra); + out.set(f.c, f.o + badd); + wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0); + } + wzf(out, o, files.length, cdl, oe); + return out; +} +/** + * Streaming pass-through decompression for ZIP archives + */ +var UnzipPassThrough = /*#__PURE__*/ (function () { + function UnzipPassThrough() { + } + UnzipPassThrough.prototype.push = function (chunk, final) { + // same as ZipPassThrough: cast to retain Buffer ergonomics + this.ondata(null, chunk, final); + }; + UnzipPassThrough.compression = 0; + return UnzipPassThrough; +}()); +exports.UnzipPassThrough = UnzipPassThrough; +/** + * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for + * better performance. + */ +var UnzipInflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + function UnzipInflate() { + var _this = this; + this.i = new Inflate(function (dat, final) { + _this.ondata(null, dat, final); + }); + } + UnzipInflate.prototype.push = function (chunk, final) { + try { + this.i.push(chunk, final); + } + catch (e) { + this.ondata(e, null, final); + } + }; + UnzipInflate.compression = 8; + return UnzipInflate; +}()); +exports.UnzipInflate = UnzipInflate; +/** + * Asynchronous streaming DEFLATE decompression for ZIP archives + */ +var AsyncUnzipInflate = /*#__PURE__*/ (function () { + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + function AsyncUnzipInflate(_, sz) { + var _this = this; + if (sz < 320000) { + this.i = new Inflate(function (dat, final) { + _this.ondata(null, dat, final); + }); + } + else { + this.i = new AsyncInflate(function (err, dat, final) { + _this.ondata(err, dat, final); + }); + this.terminate = this.i.terminate; + } + } + AsyncUnzipInflate.prototype.push = function (chunk, final) { + if (this.i.terminate) + chunk = slc(chunk, 0); + this.i.push(chunk, final); + }; + AsyncUnzipInflate.compression = 8; + return AsyncUnzipInflate; +}()); +exports.AsyncUnzipInflate = AsyncUnzipInflate; +/** + * A ZIP archive decompression stream that emits files as they are discovered + */ +var Unzip = /*#__PURE__*/ (function () { + /** + * Creates a ZIP decompression stream + * @param cb The callback to call whenever a file in the ZIP archive is found + */ + function Unzip(cb) { + this.onfile = cb; + this.k = []; + this.o = { + 0: UnzipPassThrough + }; + this.p = et; + } + /** + * Pushes a chunk to be unzipped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + Unzip.prototype.push = function (chunk, final) { + var _this = this; + if (!this.onfile) + err(5); + if (!this.p) + err(4); + if (this.c > 0) { + var len = Math.min(this.c, chunk.length); + var toAdd = chunk.subarray(0, len); + this.c -= len; + if (this.d) + this.d.push(toAdd, !this.c); + else + this.k[0].push(toAdd); + chunk = chunk.subarray(len); + if (chunk.length) + return this.push(chunk, final); + } + else { + var f = 0, i = 0, is = void 0, buf = void 0; + if (!this.p.length) + buf = chunk; + else if (!chunk.length) + buf = this.p; + else { + buf = new u8(this.p.length + chunk.length); + buf.set(this.p), buf.set(chunk, this.p.length); + } + var l = buf.length, oc = this.c, add = oc && this.d; + var _loop_2 = function () { + var sig = b4(buf, i); + if (sig == 0x4034B50) { + f = 1, is = i; + this_1.d = null; + this_1.c = 0; + var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28); + if (l > i + 30 + fnl + es) { + var chks_3 = []; + this_1.k.unshift(chks_3); + f = 2; + var lsc = b4(buf, i + 18), lsu = b4(buf, i + 22); + var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u); + var _a = z64hs(buf, i, es, 2, lsc, lsu, 0), sc_1 = _a[0], su_1 = _a[1], z64 = _a[3]; + if (dd) + sc_1 = -1 - z64; + i += es; + this_1.c = sc_1; + var d_1; + var file_1 = { + name: fn_1, + compression: cmp_1, + start: function () { + if (!file_1.ondata) + err(5); + if (!sc_1) + file_1.ondata(null, et, true); + else { + var ctr = _this.o[cmp_1]; + if (!ctr) + file_1.ondata(err(14, 'unknown compression type ' + cmp_1, 1), null, false); + d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1); + d_1.ondata = function (err, dat, final) { file_1.ondata(err, dat, final); }; + for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) { + var dat = chks_4[_i]; + d_1.push(dat, false); + } + if (_this.k[0] == chks_3 && _this.c) + _this.d = d_1; + else + d_1.push(et, true); + } + }, + terminate: function () { + if (d_1 && d_1.terminate) + d_1.terminate(); + } + }; + if (sc_1 >= 0) + file_1.size = sc_1, file_1.originalSize = su_1; + this_1.onfile(file_1); + } + return "break"; + } + else if (oc) { + if (sig == 0x8074B50) { + is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0; + return "break"; + } + else if (sig == 0x2014B50) { + is = i -= 4, f = 3, this_1.c = 0; + return "break"; + } + } + }; + var this_1 = this; + for (; i < l - 4; ++i) { + var state_1 = _loop_2(); + if (state_1 === "break") + break; + } + this.p = et; + if (oc < 0) { + var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 0x8074B50 && 4)) : buf.subarray(0, i); + if (add) + add.push(dat, !!f); + else + this.k[+(f == 2)].push(dat); + } + if (f & 2) + return this.push(buf.subarray(i), final); + this.p = buf.subarray(i); + } + if (final) { + if (this.c) + err(13); + this.p = null; + } + }; + /** + * Registers a decoder with the stream, allowing for files compressed with + * the compression type provided to be expanded correctly + * @param decoder The decoder constructor + */ + Unzip.prototype.register = function (decoder) { + this.o[decoder.compression] = decoder; + }; + return Unzip; +}()); +exports.Unzip = Unzip; +var mt = typeof queueMicrotask == 'function' ? queueMicrotask : typeof setTimeout == 'function' ? setTimeout : function (fn) { fn(); }; +function unzip(data, opts, cb) { + if (!cb) + cb = opts, opts = {}; + if (typeof cb != 'function') + err(7); + var term = []; + var tAll = function () { + for (var i = 0; i < term.length; ++i) + term[i](); + }; + var files = {}; + var cbd = function (a, b) { + mt(function () { cb(a, b); }); + }; + mt(function () { cbd = cb; }); + var e = data.length - 22; + for (; b4(data, e) != 0x6054B50; --e) { + if (!e || data.length - e > 65558) { + cbd(err(13, 0, 1), null); + return tAll; + } + } + ; + var lft = b2(data, e + 8); + if (lft) { + var c = lft; + var o = b4(data, e + 16); + var z = b4(data, e - 20) == 0x7064B50; + if (z) { + var ze = b4(data, e - 12); + z = b4(data, ze) == 0x6064B50; + if (z) { + c = lft = b4(data, ze + 32); + o = b4(data, ze + 48); + } + } + var fltr = opts && opts.filter; + var _loop_3 = function (i) { + var _a = zh(data, o, z), c_1 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off); + o = no; + var cbl = function (e, d) { + if (e) { + tAll(); + cbd(e, null); + } + else { + if (d) + files[fn] = d; + if (!--lft) + cbd(null, files); + } + }; + if (!fltr || fltr({ + name: fn, + size: sc, + originalSize: su, + compression: c_1 + })) { + if (!c_1) + cbl(null, slc(data, b, b + sc)); + else if (c_1 == 8) { + var infl = data.subarray(b, b + sc); + // Synchronously decompress under 512KB, or barely-compressed data + if (su < 524288 || sc > 0.8 * su) { + try { + cbl(null, inflateSync(infl, { out: new u8(su) })); + } + catch (e) { + cbl(e, null); + } + } + else + term.push(inflate(infl, { size: su }, cbl)); + } + else + cbl(err(14, 'unknown compression type ' + c_1, 1), null); + } + else + cbl(null, null); + }; + for (var i = 0; i < c; ++i) { + _loop_3(i); + } + } + else + cbd(null, {}); + return tAll; +} +/** + * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better + * performance with more than one file. + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @returns The decompressed files + */ +function unzipSync(data, opts) { + var files = {}; + var e = data.length - 22; + for (; b4(data, e) != 0x6054B50; --e) { + if (!e || data.length - e > 65558) + err(13); + } + ; + var c = b2(data, e + 8); + if (!c) + return {}; + var o = b4(data, e + 16); + var z = b4(data, e - 20) == 0x7064B50; + if (z) { + var ze = b4(data, e - 12); + z = b4(data, ze) == 0x6064B50; + if (z) { + c = b4(data, ze + 32); + o = b4(data, ze + 48); + } + } + var fltr = opts && opts.filter; + for (var i = 0; i < c; ++i) { + var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off); + o = no; + if (!fltr || fltr({ + name: fn, + size: sc, + originalSize: su, + compression: c_2 + })) { + if (!c_2) + files[fn] = slc(data, b, b + sc); + else if (c_2 == 8) + files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) }); + else + err(14, 'unknown compression type ' + c_2); + } + } + return files; +} diff --git a/tools/ui/node_modules/fflate/lib/node.d.cts b/tools/ui/node_modules/fflate/lib/node.d.cts new file mode 100644 index 0000000000000000000000000000000000000000..d430faf2b555c978d66c89f46155b72c2c45a971 --- /dev/null +++ b/tools/ui/node_modules/fflate/lib/node.d.cts @@ -0,0 +1,1539 @@ +/** + * Codes for errors generated within this library + */ +export declare const FlateErrorCode: { + readonly UnexpectedEOF: 0; + readonly InvalidBlockType: 1; + readonly InvalidLengthLiteral: 2; + readonly InvalidDistance: 3; + readonly StreamFinished: 4; + readonly NoStreamHandler: 5; + readonly InvalidHeader: 6; + readonly NoCallback: 7; + readonly InvalidUTF8: 8; + readonly ExtraFieldTooLong: 9; + readonly InvalidDate: 10; + readonly FilenameTooLong: 11; + readonly StreamFinishing: 12; + readonly InvalidZipData: 13; + readonly UnknownCompressionMethod: 14; +}; +/** + * An error generated within this library + */ +export interface FlateError extends Error { + /** + * The code associated with this error + */ + code: number; +} +/** + * Options for decompressing a DEFLATE stream + */ +export interface InflateStreamOptions { + /** + * The dictionary used to compress the original data. If no dictionary was used during compression, this option has no effect. + * + * Supplying the wrong dictionary during decompression usually yields corrupt output or causes an invalid distance error. + */ + dictionary?: Uint8Array; +} +/** + * Options for decompressing DEFLATE data + */ +export interface InflateOptions extends InflateStreamOptions { + /** + * The buffer into which to write the decompressed data. Saves memory if you know the decompressed size in advance. + * + * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit. + */ + out?: Uint8Array; +} +/** + * Options for decompressing a GZIP stream + */ +export interface GunzipStreamOptions extends InflateStreamOptions { +} +/** + * Options for decompressing GZIP data + */ +export interface GunzipOptions extends InflateStreamOptions { + /** + * The buffer into which to write the decompressed data. GZIP already encodes the output size, so providing this doesn't save memory. + * + * Note that if the decompression result is larger than the size of this buffer, it will be truncated to fit. + */ + out?: Uint8Array; +} +/** + * Options for decompressing a Zlib stream + */ +export interface UnzlibStreamOptions extends InflateStreamOptions { +} +/** + * Options for decompressing Zlib data + */ +export interface UnzlibOptions extends InflateOptions { +} +/** + * Options for compressing data into a DEFLATE format + */ +export interface DeflateOptions { + /** + * The level of compression to use, ranging from 0-9. + * + * 0 will store the data without compression. + * 1 is fastest but compresses the worst, 9 is slowest but compresses the best. + * The default level is 6. + * + * Typically, binary data benefits much more from higher values than text data. + * In both cases, higher values usually take disproportionately longer than the reduction in final size that results. + * + * For example, a 1 MB text file could: + * - become 1.01 MB with level 0 in 1ms + * - become 400 kB with level 1 in 10ms + * - become 320 kB with level 9 in 100ms + */ + level?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9; + /** + * The memory level to use, ranging from 0-12. Increasing this increases speed and compression ratio at the cost of memory. + * + * Note that this is exponential: while level 0 uses 8 kB, level 4 uses 128 kB, level 8 uses 2 MB, and level 12 uses 32 MB. + * It is recommended not to lower the value below 4, since that tends to hurt performance. + * In addition, values above 8 tend to help very little on most data and can even hurt performance. + * + * The default value is automatically determined based on the size of the input data. + */ + mem?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12; + /** + * A buffer containing common byte sequences in the input data that can be used to significantly improve compression ratios. + * + * Dictionaries should be 32kB or smaller and include strings or byte sequences likely to appear in the input. + * The decompressor must supply the same dictionary as the compressor to extract the original data. + * + * Dictionaries only improve aggregate compression ratio when reused across multiple small inputs. They should typically not be used otherwise. + * + * Avoid using dictionaries with GZIP and ZIP to maximize software compatibility. + */ + dictionary?: Uint8Array; +} +/** + * Options for compressing data into a GZIP format + */ +export interface GzipOptions extends DeflateOptions { + /** + * When the file was last modified. Defaults to the current time. + * Set this to 0 to avoid revealing a modification date entirely. + */ + mtime?: Date | string | number; + /** + * The filename of the data. If the `gunzip` command is used to decompress the data, it will output a file + * with this name instead of the name of the compressed file. + */ + filename?: string; +} +/** + * Options for compressing data into a Zlib format + */ +export interface ZlibOptions extends DeflateOptions { +} +/** + * Handler for data (de)compression streams + * @param data The data output from the stream processor + * @param final Whether this is the final block + */ +export type FlateStreamHandler = (data: Uint8Array, final: boolean) => void; +/** + * Handler for asynchronous data (de)compression streams + * @param err Any error that occurred + * @param data The data output from the stream processor + * @param final Whether this is the final block + */ +export type AsyncFlateStreamHandler = (err: FlateError | null, data: Uint8Array, final: boolean) => void; +/** + * Handler for the asynchronous completion of (de)compression for a data chunk + * @param size The number of bytes that were processed. This is measured in terms of the input + * (i.e. compressed bytes for decompression, uncompressed bytes for compression.) + */ +export type AsyncFlateDrainHandler = (size: number) => void; +/** + * Callback for asynchronous (de)compression methods + * @param err Any error that occurred + * @param data The resulting data. Only present if `err` is null + */ +export type FlateCallback = (err: FlateError | null, data: Uint8Array) => void; +interface AsyncOptions { + /** + * Whether or not to "consume" the source data. This will make the typed array/buffer you pass in + * unusable but will increase performance and reduce memory usage. + */ + consume?: boolean; +} +/** + * Options for compressing data asynchronously into a DEFLATE format + */ +export interface AsyncDeflateOptions extends DeflateOptions, AsyncOptions { +} +/** + * Options for decompressing DEFLATE data asynchronously + */ +export interface AsyncInflateOptions extends AsyncOptions, InflateStreamOptions { + /** + * The original size of the data. Currently, the asynchronous API disallows + * writing into a buffer you provide; the best you can do is provide the + * size in bytes and be given back a new typed array. + */ + size?: number; +} +/** + * Options for compressing data asynchronously into a GZIP format + */ +export interface AsyncGzipOptions extends GzipOptions, AsyncOptions { +} +/** + * Options for decompressing GZIP data asynchronously + */ +export interface AsyncGunzipOptions extends AsyncOptions, InflateStreamOptions { +} +/** + * Options for compressing data asynchronously into a Zlib format + */ +export interface AsyncZlibOptions extends ZlibOptions, AsyncOptions { +} +/** + * Options for decompressing Zlib data asynchronously + */ +export interface AsyncUnzlibOptions extends AsyncInflateOptions { +} +/** + * A terminable compression/decompression process + */ +export interface AsyncTerminable { + /** + * Terminates the worker thread immediately. The callback will not be called. + */ + (): void; +} +/** + * Streaming DEFLATE compression + */ +export declare class Deflate { + /** + * Creates a DEFLATE stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: DeflateOptions, cb?: FlateStreamHandler); + /** + * Creates a DEFLATE stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + private b; + private s; + private o; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + private p; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE compression + */ +export declare class AsyncDeflate { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous DEFLATE stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: DeflateOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous DEFLATE stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * deflated output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. A separate DEFLATE stream may be concatenated + * with the current output after a sync flush. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function deflate(data: Uint8Array, opts: AsyncDeflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param cb The function to be called upon compression completion + */ +export declare function deflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compresses data with DEFLATE without any wrapper + * @param data The data to compress + * @param opts The compression options + * @returns The deflated version of the data + */ +export declare function deflateSync(data: Uint8Array, opts?: DeflateOptions): Uint8Array; +/** + * Streaming DEFLATE decompression + */ +export declare class Inflate { + private s; + private o; + private p; + private d; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a DEFLATE decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: InflateStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a DEFLATE decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + private e; + private c; + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the final chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE decompression + */ +export declare class AsyncInflate { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous DEFLATE decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: InflateStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous DEFLATE decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be inflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function inflate(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function inflate(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands DEFLATE data with no wrapper + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function inflateSync(data: Uint8Array): Uint8Array; +/** + * Expands DEFLATE data with no wrapper + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function inflateSync(data: Uint8Array, opts?: InflateOptions): Uint8Array; +/** + * Streaming GZIP compression + */ +export declare class Gzip { + private c; + private l; + private v; + private o; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a GZIP stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: GzipOptions, cb?: FlateStreamHandler); + /** + * Creates a GZIP stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + private p; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming GZIP compression + */ +export declare class AsyncGzip { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous GZIP stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: GzipOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous GZIP stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be GZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * GZIPped output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function gzip(data: Uint8Array, opts: AsyncGzipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with GZIP + * @param data The data to compress + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compresses data with GZIP + * @param data The data to compress + * @param opts The compression options + * @returns The gzipped version of the data + */ +export declare function gzipSync(data: Uint8Array, opts?: GzipOptions): Uint8Array; +/** + * Handler for new GZIP members in concatenated GZIP streams. Useful for building indices used to perform random-access reads on compressed files. + * @param offset The offset of the new member relative to the start of the stream + */ +export type GunzipMemberHandler = (offset: number) => void; +/** + * Streaming single or multi-member GZIP decompression + */ +export declare class Gunzip { + private v; + private r; + private o; + private p; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * The handler to call whenever a new GZIP member is found + */ + onmember?: GunzipMemberHandler; + /** + * Creates a GUNZIP stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: GunzipStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a GUNZIP stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming single or multi-member GZIP decompression + */ +export declare class AsyncGunzip { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * The handler to call whenever a new GZIP member is found + */ + onmember?: GunzipMemberHandler; + /** + * Creates an asynchronous GUNZIP stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: GunzipStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous GUNZIP stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be GUNZIPped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands GZIP data + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gunzip(data: Uint8Array, opts: AsyncGunzipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands GZIP data + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function gunzip(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands GZIP data + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function gunzipSync(data: Uint8Array): Uint8Array; +/** + * Expands GZIP data + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function gunzipSync(data: Uint8Array, opts?: GunzipOptions): Uint8Array; +/** + * Streaming Zlib compression + */ +export declare class Zlib { + private c; + private v; + private o; + private s; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a Zlib stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: ZlibOptions, cb?: FlateStreamHandler); + /** + * Creates a Zlib stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be zlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + private p; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; +} +/** + * Asynchronous streaming Zlib compression + */ +export declare class AsyncZlib { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of uncompressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous Zlib stream + * @param opts The compression options + * @param cb The callback to call whenever data is deflated + */ + constructor(opts: ZlibOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous Zlib stream + * @param cb The callback to call whenever data is deflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Flushes buffered uncompressed data. Useful to immediately retrieve the + * zlibbed output for small inputs. + * @param sync Whether to flush to a byte boundary. A sync flush takes 4-5 + * extra bytes, but guarantees all pushed data is immediately + * decompressible. + */ + flush(sync?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously compresses data with Zlib + * @param data The data to compress + * @param opts The compression options + * @param cb The function to be called upon compression completion + */ +export declare function zlib(data: Uint8Array, opts: AsyncZlibOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously compresses data with Zlib + * @param data The data to compress + * @param cb The function to be called upon compression completion + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Compress data with Zlib + * @param data The data to compress + * @param opts The compression options + * @returns The zlib-compressed version of the data + */ +export declare function zlibSync(data: Uint8Array, opts?: ZlibOptions): Uint8Array; +/** + * Streaming Zlib decompression + */ +export declare class Unzlib { + private v; + private p; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a Zlib decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: UnzlibStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a Zlib decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be unzlibbed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming Zlib decompression + */ +export declare class AsyncUnzlib { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous Zlib decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is inflated + */ + constructor(opts: UnzlibStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous Zlib decompression stream + * @param cb The callback to call whenever data is inflated + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Pushes a chunk to be decompressed from Zlib + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * A method to terminate the stream's internal worker. Subsequent calls to + * push() will silently fail. + */ + terminate: AsyncTerminable; +} +/** + * Asynchronously expands Zlib data + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function unzlib(data: Uint8Array, opts: AsyncUnzlibOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously expands Zlib data + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function unzlib(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands Zlib data + * @param data The data to decompress + * @returns The decompressed version of the data + */ +export declare function unzlibSync(data: Uint8Array): Uint8Array; +/** + * Expands Zlib data + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function unzlibSync(data: Uint8Array, opts?: UnzlibOptions): Uint8Array; +export { gzip as compress, AsyncGzip as AsyncCompress }; +export { gzipSync as compressSync, Gzip as Compress }; +/** + * Streaming GZIP, Zlib, or raw DEFLATE decompression + */ +export declare class Decompress { + private G; + private I; + private Z; + private o; + private s; + private p; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; + /** + * Creates a decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is decompressed + */ + constructor(opts: InflateStreamOptions, cb?: FlateStreamHandler); + /** + * Creates a decompression stream + * @param cb The callback to call whenever data is decompressed + */ + constructor(cb?: FlateStreamHandler); + private i; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression + */ +export declare class AsyncDecompress { + private G; + private I; + private Z; + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The handler to call whenever buffered source data is processed (i.e. `queuedSize` updates) + */ + ondrain?: AsyncFlateDrainHandler; + /** + * The number of compressed bytes buffered in the stream + */ + queuedSize: number; + /** + * Creates an asynchronous decompression stream + * @param opts The decompression options + * @param cb The callback to call whenever data is decompressed + */ + constructor(opts: InflateStreamOptions, cb?: AsyncFlateStreamHandler); + /** + * Creates an asynchronous decompression stream + * @param cb The callback to call whenever data is decompressed + */ + constructor(cb?: AsyncFlateStreamHandler); + private i; + /** + * Pushes a chunk to be decompressed + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function decompress(data: Uint8Array, opts: AsyncInflateOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchrononously expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param cb The function to be called upon decompression completion + * @returns A function that can be used to immediately terminate the decompression + */ +export declare function decompress(data: Uint8Array, cb: FlateCallback): AsyncTerminable; +/** + * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format + * @param data The data to decompress + * @param opts The decompression options + * @returns The decompressed version of the data + */ +export declare function decompressSync(data: Uint8Array, opts?: InflateOptions): Uint8Array; +/** + * Attributes for files added to a ZIP archive object + */ +export interface ZipAttributes { + /** + * The operating system of origin for this file. The value is defined + * by PKZIP's APPNOTE.txt, section 4.4.2.2. For example, 0 (the default) + * is MS/DOS, 3 is Unix, 19 is macOS. + */ + os?: number; + /** + * The file's attributes. These are traditionally somewhat complicated + * and platform-dependent, so using them is scarcely necessary. However, + * here is a representation of what this is, bit by bit: + * + * `TTTTugtrwxrwxrwx0000000000ADVSHR` + * + * TTTT = file type (rarely useful) + * + * u = setuid, g = setgid, t = sticky + * + * rwx = user permissions, rwx = group permissions, rwx = other permissions + * + * 0000000000 = unused + * + * A = archive, D = directory, V = volume label, S = system file, H = hidden, R = read-only + * + * If you want to set the Unix permissions, for instance, just bit shift by 16, e.g. 0o644 << 16. + * Note that attributes usually only work in conjunction with the `os` setting: you must use + * `os` = 3 (Unix) if you want to set Unix permissions + */ + attrs?: number; + /** + * Extra metadata to add to the file. This field is defined by PKZIP's APPNOTE.txt, + * section 4.4.28. At most 65,535 bytes may be used in each ID. The ID must be an + * integer between 0 and 65,535, inclusive. + * + * This field is incredibly rare and almost never needed except for compliance with + * proprietary standards and software. + */ + extra?: Record; + /** + * The comment to attach to the file. This field is defined by PKZIP's APPNOTE.txt, + * section 4.4.26. The comment must be at most 65,535 bytes long UTF-8 encoded. This + * field is not read by consumer software. + */ + comment?: string; + /** + * When the file was last modified. Defaults to the current time. + */ + mtime?: GzipOptions['mtime']; +} +/** + * Options for creating a ZIP archive + */ +export interface ZipOptions extends DeflateOptions, ZipAttributes { +} +/** + * Options for expanding a ZIP archive + */ +export interface UnzipOptions { + /** + * A filter function to extract only certain files from a ZIP archive + */ + filter?: UnzipFileFilter; +} +/** + * Options for asynchronously creating a ZIP archive + */ +export interface AsyncZipOptions extends AsyncDeflateOptions, ZipAttributes { +} +/** + * Options for asynchronously expanding a ZIP archive + */ +export interface AsyncUnzipOptions extends UnzipOptions { +} +/** + * A file that can be used to create a ZIP archive + */ +export type ZippableFile = Uint8Array | Zippable | [Uint8Array | Zippable, ZipOptions]; +/** + * A file that can be used to asynchronously create a ZIP archive + */ +export type AsyncZippableFile = Uint8Array | AsyncZippable | [Uint8Array | AsyncZippable, AsyncZipOptions]; +/** + * The complete directory structure of a ZIPpable archive + */ +export interface Zippable { + [path: string]: ZippableFile; +} +/** + * The complete directory structure of an asynchronously ZIPpable archive + */ +export interface AsyncZippable { + [path: string]: AsyncZippableFile; +} +/** + * An unzipped archive. The full path of each file is used as the key, + * and the file is the value + */ +export interface Unzipped { + [path: string]: Uint8Array; +} +/** + * Handler for string generation streams + * @param data The string output from the stream processor + * @param final Whether this is the final block + */ +export type StringStreamHandler = (data: string, final: boolean) => void; +/** + * Callback for asynchronous ZIP decompression + * @param err Any error that occurred + * @param data The decompressed ZIP archive + */ +export type UnzipCallback = (err: FlateError | null, data: Unzipped) => void; +/** + * Handler for streaming ZIP decompression + * @param file The file that was found in the archive + */ +export type UnzipFileHandler = (file: UnzipFile) => void; +/** + * Streaming UTF-8 decoding + */ +export declare class DecodeUTF8 { + private p; + private t; + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is decoded + */ + constructor(cb?: StringStreamHandler); + /** + * Pushes a chunk to be decoded from UTF-8 binary + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * The handler to call whenever data is available + */ + ondata: StringStreamHandler; +} +/** + * Streaming UTF-8 encoding + */ +export declare class EncodeUTF8 { + private d; + /** + * Creates a UTF-8 decoding stream + * @param cb The callback to call whenever data is encoded + */ + constructor(cb?: FlateStreamHandler); + /** + * Pushes a chunk to be encoded to UTF-8 + * @param chunk The string data to push + * @param final Whether this is the last chunk + */ + push(chunk: string, final?: boolean): void; + /** + * The handler to call whenever data is available + */ + ondata: FlateStreamHandler; +} +/** + * Converts a string into a Uint8Array for use with compression/decompression methods + * @param str The string to encode + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless decoding a binary string. + * @returns The string encoded in UTF-8/Latin-1 binary + */ +export declare function strToU8(str: string, latin1?: boolean): Uint8Array; +/** + * Converts a Uint8Array to a string + * @param dat The data to decode to string + * @param latin1 Whether or not to interpret the data as Latin-1. This should + * not need to be true unless encoding to binary string. + * @returns The original UTF-8/Latin-1 string + */ +export declare function strFromU8(dat: Uint8Array, latin1?: boolean): string; +/** + * A stream that can be used to create a file in a ZIP archive + */ +export interface ZipInputFile extends ZipAttributes { + /** + * The filename to associate with the data provided to this stream. If you + * want a file in a subdirectory, use forward slashes as a separator (e.g. + * `directory/filename.ext`). This will still work on Windows. + */ + filename: string; + /** + * The size of the file in bytes. This attribute may be invalid after + * the file is added to the ZIP archive; it must be correct only before the + * stream completes. + * + * If you don't want to have to compute this yourself, consider extending the + * ZipPassThrough class and overriding its process() method, or using one of + * ZipDeflate or AsyncZipDeflate. + */ + size: number; + /** + * A CRC of the original file contents. This attribute may be invalid after + * the file is added to the ZIP archive; it must be correct only before the + * stream completes. + * + * If you don't want to have to generate this yourself, consider extending the + * ZipPassThrough class and overriding its process() method, or using one of + * ZipDeflate or AsyncZipDeflate. + */ + crc: number; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA + */ + compression: number; + /** + * Bits 1 and 2 of the general purpose bit flag, specified in PKZIP's + * APPNOTE.txt, section 4.4.4. Should be between 0 and 3. This is unlikely + * to be necessary. + */ + flag?: number; + /** + * The handler to be called when data is added. After passing this stream to + * the ZIP file object, this handler will always be defined. To call it: + * + * `stream.ondata(error, chunk, final)` + * + * error = any error that occurred (null if there was no error) + * + * chunk = a Uint8Array of the data that was added (null if there was an + * error) + * + * final = boolean, whether this is the final chunk in the stream + */ + ondata?: AsyncFlateStreamHandler; + /** + * A method called when the stream is no longer needed, for clean-up + * purposes. This will not always be called after the stream completes, + * so you may wish to call this.terminate() after the final chunk is + * processed if you have clean-up logic. + */ + terminate?: AsyncTerminable; +} +/** + * A pass-through stream to keep data uncompressed in a ZIP archive. + */ +export declare class ZipPassThrough implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private c; + /** + * Creates a pass-through stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + */ + constructor(filename: string); + /** + * Processes a chunk and pushes to the output stream. You can override this + * method in a subclass for custom behavior, but by default this passes + * the data through. You must call this.ondata(err, chunk, final) at some + * point in this method. + * @param chunk The chunk to process + * @param final Whether this is the last chunk + */ + protected process(chunk: Uint8Array, final: boolean): void; + /** + * Pushes a chunk to be added. If you are subclassing this with a custom + * compression algorithm, note that you must push data from the source + * file only, pre-compression. + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate + * for better performance + */ +export declare class ZipDeflate implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + flag: 0 | 1 | 2 | 3; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private d; + /** + * Creates a DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + constructor(filename: string, opts?: DeflateOptions); + private process; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * Asynchronous streaming DEFLATE compression for ZIP archives + */ +export declare class AsyncZipDeflate implements ZipInputFile { + filename: string; + crc: number; + size: number; + compression: number; + flag: 0 | 1 | 2 | 3; + os?: number; + attrs?: number; + comment?: string; + extra?: Record; + mtime?: GzipOptions['mtime']; + ondata: AsyncFlateStreamHandler; + private d; + terminate: AsyncTerminable; + /** + * Creates an asynchronous DEFLATE stream that can be added to ZIP archives + * @param filename The filename to associate with this data stream + * @param opts The compression options + */ + constructor(filename: string, opts?: DeflateOptions); + private process; + /** + * Pushes a chunk to be deflated + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; +} +/** + * A zippable archive to which files can incrementally be added + */ +export declare class Zip { + private u; + private d; + /** + * Creates an empty ZIP archive to which files can be added + * @param cb The callback to call whenever data for the generated ZIP archive + * is available + */ + constructor(cb?: AsyncFlateStreamHandler); + /** + * Adds a file to the ZIP archive + * @param file The file stream to add + */ + add(file: ZipInputFile): void; + /** + * Ends the process of adding files and prepares to emit the final chunks. + * This *must* be called after adding all desired files for the resulting + * ZIP file to work properly. + */ + end(): void; + private e; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to add() will fail. + */ + terminate(): void; + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; +} +/** + * Asynchronously creates a ZIP file + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @param cb The callback to call with the generated ZIP archive + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zip(data: AsyncZippable, opts: AsyncZipOptions, cb: FlateCallback): AsyncTerminable; +/** + * Asynchronously creates a ZIP file + * @param data The directory structure for the ZIP archive + * @param cb The callback to call with the generated ZIP archive + * @returns A function that can be used to immediately terminate the compression + */ +export declare function zip(data: AsyncZippable, cb: FlateCallback): AsyncTerminable; +/** + * Synchronously creates a ZIP file. Prefer using `zip` for better performance + * with more than one file. + * @param data The directory structure for the ZIP archive + * @param opts The main options, merged with per-file options + * @returns The generated ZIP archive + */ +export declare function zipSync(data: Zippable, opts?: ZipOptions): Uint8Array; +/** + * A decoder for files in ZIP streams + */ +export interface UnzipDecoder { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * Pushes a chunk to be decompressed + * @param chunk The data in this chunk. Do not consume (detach) this buffer. + * @param final Whether this is the last chunk in the data stream + */ + push(chunk: Uint8Array, final: boolean): void; + /** + * A method to terminate any internal workers used by the stream. Subsequent + * calls to push() should silently fail. + */ + terminate?: AsyncTerminable; +} +/** + * A constructor for a decoder for unzip streams + */ +export interface UnzipDecoderConstructor { + /** + * Creates an instance of the decoder + * @param filename The name of the file + * @param size The compressed size of the file + * @param originalSize The original size of the file + */ + new (filename: string, size?: number, originalSize?: number): UnzipDecoder; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA + */ + compression: number; +} +/** + * Information about a file to be extracted from a ZIP archive + */ +export interface UnzipFileInfo { + /** + * The name of the file + */ + name: string; + /** + * The compressed size of the file + */ + size: number; + /** + * The original size of the file + */ + originalSize: number; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA. If the filter function returns true + * but this value is not 8, the unzip function will throw. + */ + compression: number; +} +/** + * A filter for files to be extracted during the unzipping process + * @param file The info for the current file being processed + * @returns Whether or not to extract the current file + */ +export type UnzipFileFilter = (file: UnzipFileInfo) => boolean; +/** + * Streaming file extraction from ZIP archives + */ +export interface UnzipFile { + /** + * The handler to call whenever data is available + */ + ondata: AsyncFlateStreamHandler; + /** + * The name of the file + */ + name: string; + /** + * The compression format for the data stream. This number is determined by + * the spec in PKZIP's APPNOTE.txt, section 4.4.5. For example, 0 = no + * compression, 8 = deflate, 14 = LZMA. If start() is called but there is no + * decompression stream available for this method, start() will throw. + */ + compression: number; + /** + * The compressed size of the file. Will not be present for archives created + * in a streaming fashion. + */ + size?: number; + /** + * The original size of the file. Will not be present for archives created + * in a streaming fashion. + */ + originalSize?: number; + /** + * Starts reading from the stream. Calling this function will always enable + * this stream, but ocassionally the stream will be enabled even without + * this being called. + */ + start(): void; + /** + * A method to terminate any internal workers used by the stream. ondata + * will not be called any further. + */ + terminate: AsyncTerminable; +} +/** + * Streaming pass-through decompression for ZIP archives + */ +export declare class UnzipPassThrough implements UnzipDecoder { + static compression: number; + ondata: AsyncFlateStreamHandler; + push(chunk: Uint8Array, final: boolean): void; +} +/** + * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for + * better performance. + */ +export declare class UnzipInflate implements UnzipDecoder { + static compression: number; + private i; + ondata: AsyncFlateStreamHandler; + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + constructor(); + push(chunk: Uint8Array, final: boolean): void; +} +/** + * Asynchronous streaming DEFLATE decompression for ZIP archives + */ +export declare class AsyncUnzipInflate implements UnzipDecoder { + static compression: number; + private i; + ondata: AsyncFlateStreamHandler; + terminate: AsyncTerminable; + /** + * Creates a DEFLATE decompression that can be used in ZIP archives + */ + constructor(_: string, sz?: number); + push(chunk: Uint8Array, final: boolean): void; +} +/** + * A ZIP archive decompression stream that emits files as they are discovered + */ +export declare class Unzip { + private d; + private c; + private p; + private k; + private o; + /** + * Creates a ZIP decompression stream + * @param cb The callback to call whenever a file in the ZIP archive is found + */ + constructor(cb?: UnzipFileHandler); + /** + * Pushes a chunk to be unzipped + * @param chunk The chunk to push + * @param final Whether this is the last chunk + */ + push(chunk: Uint8Array, final?: boolean): void; + /** + * Registers a decoder with the stream, allowing for files compressed with + * the compression type provided to be expanded correctly + * @param decoder The decoder constructor + */ + register(decoder: UnzipDecoderConstructor): void; + /** + * The handler to call whenever a file is discovered + */ + onfile: UnzipFileHandler; +} +/** + * Asynchronously decompresses a ZIP archive + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @param cb The callback to call with the decompressed files + * @returns A function that can be used to immediately terminate the unzipping + */ +export declare function unzip(data: Uint8Array, opts: AsyncUnzipOptions, cb: UnzipCallback): AsyncTerminable; +/** + * Asynchronously decompresses a ZIP archive + * @param data The raw compressed ZIP file + * @param cb The callback to call with the decompressed files + * @returns A function that can be used to immediately terminate the unzipping + */ +export declare function unzip(data: Uint8Array, cb: UnzipCallback): AsyncTerminable; +/** + * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better + * performance with more than one file. + * @param data The raw compressed ZIP file + * @param opts The ZIP extraction options + * @returns The decompressed files + */ +export declare function unzipSync(data: Uint8Array, opts?: UnzipOptions): Unzipped; diff --git a/tools/ui/node_modules/fflate/lib/worker.cjs b/tools/ui/node_modules/fflate/lib/worker.cjs new file mode 100644 index 0000000000000000000000000000000000000000..9a283bdb82464d89f8cdc9b9c879d88b50c9acff --- /dev/null +++ b/tools/ui/node_modules/fflate/lib/worker.cjs @@ -0,0 +1,20 @@ +"use strict"; +var ch2 = {}; +exports.default = (function (c, id, msg, transfer, cb) { + var w = new Worker(ch2[id] || (ch2[id] = URL.createObjectURL(new Blob([ + c + ';addEventListener("error",function(e){e=e.error;postMessage({$e$:[e.message,e.code,e.stack]})})' + ], { type: 'text/javascript' })))); + w.onmessage = function (e) { + var d = e.data, ed = d.$e$; + if (ed) { + var err = new Error(ed[0]); + err['code'] = ed[1]; + err.stack = ed[2]; + cb(err, null); + } + else + cb(null, d); + }; + w.postMessage(msg, transfer); + return w; +}); diff --git a/tools/ui/node_modules/fflate/package.json b/tools/ui/node_modules/fflate/package.json new file mode 100644 index 0000000000000000000000000000000000000000..c37a5362657035a5abc0fdb65dccaafde5f48764 --- /dev/null +++ b/tools/ui/node_modules/fflate/package.json @@ -0,0 +1,128 @@ +{ + "name": "fflate", + "version": "0.8.3", + "description": "High performance (de)compression in an 8kB package", + "main": "./lib/index.cjs", + "module": "./esm/browser.js", + "types": "./lib/index.d.ts", + "unpkg": "./umd/index.js", + "jsdelivr": "./umd/index.js", + "browser": { + "./lib/node-worker.cjs": "./lib/worker.cjs" + }, + "exports": { + ".": { + "node": { + "import": { + "types": "./esm/index.d.mts", + "default": "./esm/index.mjs" + }, + "require": { + "types": "./lib/node.d.cts", + "default": "./lib/node.cjs" + } + }, + "import": { + "types": "./esm/browser.d.ts", + "default": "./esm/browser.js" + }, + "require": { + "types": "./lib/browser.d.cts", + "default": "./lib/browser.cjs" + } + }, + "./node": { + "import": { + "types": "./esm/index.d.mts", + "default": "./esm/index.mjs" + }, + "require": { + "types": "./lib/node.d.cts", + "default": "./lib/node.cjs" + } + }, + "./browser": { + "import": { + "types": "./esm/browser.d.ts", + "default": "./esm/browser.js" + }, + "require": { + "types": "./lib/browser.d.cts", + "default": "./lib/browser.cjs" + } + }, + "./package.json": "./package.json" + }, + "targets": { + "main": false, + "module": false, + "browser": false, + "types": false + }, + "sideEffects": false, + "homepage": "https://101arrowz.github.io/fflate", + "repository": "https://github.com/101arrowz/fflate", + "bugs": { + "email": "arjunbarrett@gmail.com", + "url": "https://github.com/101arrowz/fflate/issues" + }, + "author": "Arjun Barrett ", + "license": "MIT", + "keywords": [ + "gzip", + "gunzip", + "deflate", + "inflate", + "compression", + "decompression", + "zlib", + "pako", + "jszip", + "browser", + "node.js", + "tiny", + "fast", + "zip", + "unzip", + "non-blocking" + ], + "scripts": { + "build": "npm run build:lib && npm run build:docs && npm run build:demo", + "script": "node -r ts-node/register scripts/$SC.ts", + "build:lib": "tsc && tsc --project tsconfig.esm.json && npm run build:rewrite && npm run build:umd", + "build:umd": "SC=buildUMD npm run script", + "build:rewrite": "SC=rewriteBuilds npm run script", + "build:demo": "tsc --project tsconfig.demo.json && parcel build demo/index.html --no-cache --public-url \"./\" && SC=cpGHPages npm run script", + "build:docs": "typedoc --plugin typedoc-plugin-markdown --hideBreadcrumbs --readme none --disableSources --excludePrivate --excludeProtected --expandParameters --githubPages false --out docs/ src/index.ts", + "test": "TS_NODE_PROJECT=test/tsconfig.json uvu -b -r ts-node/register test", + "prepack": "npm run build && npm run test" + }, + "devDependencies": { + "@parcel/service-worker": "^2.9.3", + "@types/node": "^25.8.0", + "@types/pako": "*", + "@types/react": "^18.2.21", + "@types/react-dom": "^18.2.7", + "jszip": "^3.10.1", + "pako": "*", + "parcel": "^2.9.3", + "preact": "^10.17.1", + "react": "^18.2.0", + "react-dom": "^18.2.0", + "simple-git": "^3.19.1", + "terser": "^5.47.1", + "tiny-inflate": "*", + "ts-node": "^10.9.2", + "typedoc": "^0.28.19", + "typedoc-plugin-markdown": "^4.11.0", + "typescript": "^6.0.3", + "uvu": "^0.5.6", + "uzip": "*" + }, + "alias": { + "react": "preact/compat", + "react-dom": "preact/compat", + "buffer": false, + "process": false + } +} diff --git a/tools/ui/node_modules/fflate/umd/index.js b/tools/ui/node_modules/fflate/umd/index.js new file mode 100644 index 0000000000000000000000000000000000000000..df762372e3ff721a72a8e9b5cf1e58f2f3ee4ea8 --- /dev/null +++ b/tools/ui/node_modules/fflate/umd/index.js @@ -0,0 +1 @@ +!function(f){typeof module!='undefined'&&typeof exports=='object'?module.exports=f():typeof define!='undefined'&&define.amd?define(f):(typeof self!='undefined'?self:this).fflate=f()}(function(){var _e={};"use strict";_e.deflate=zt,_e.deflateSync=kt,_e.inflate=At,_e.inflateSync=Tt,_e.gzip=It,_e.compress=It,_e.gzipSync=Ut,_e.compressSync=Ut,_e.gunzip=Zt,_e.gunzipSync=qt,_e.zlib=Lt,_e.zlibSync=Bt,_e.unzlib=Nt,_e.unzlibSync=Pt,_e.gzip=It,_e.compress=It,_e.decompress=Jt,_e.decompressSync=Kt,_e.strToU8=nn,_e.strFromU8=rn,_e.zip=dn,_e.zipSync=gn,_e.unzip=zn,_e.unzipSync=kn;var t=(typeof module!='undefined'&&typeof exports=='object'?function(_f){"use strict";var e,r,t,n=";var __w=require('worker_threads');__w.parentPort.on('message',function(m){onmessage({data:m})}),postMessage=function(m,t){__w.parentPort.postMessage(m,t)},close=process.exit;self=global";try{e=require("worker_threads"),r=e.Worker,t=e.isMarkedAsUntransferable}catch(e){}exports.default=r?function(e,o,a,s,u){var i=!1,l=new r(e+n,{eval:!0}).on("error",function(e){return u(e,null)}).on("message",function(e){return u(null,e)}).on("exit",function(e){e&&!i&&u(Error("exited with code "+e),null)});return t&&(s=s.filter(function(e){return!t(e)})),l.postMessage(a,s),l.terminate=function(){return i=!0,r.prototype.terminate.call(l)},l}:function(e,r,t,n,o){setImmediate(function(){return o(Error("async operations unsupported - update to Node 12+ (or Node 10-11 with the --experimental-worker CLI flag)"),null)});var a=function(){};return{terminate:a,postMessage:a}};return _f}:function(_f){"use strict";var e={};_f.default=function(r,t,s,a,n){var o=new Worker(e[t]||(e[t]=URL.createObjectURL(new Blob([r+';addEventListener("error",function(e){e=e.error;postMessage({$e$:[e.message,e.code,e.stack]})})'],{type:"text/javascript"}))));return o.onmessage=function(e){var r=e.data,t=r.$e$;if(t){var s=Error(t[0]);s.code=t[1],s.stack=t[2],n(s,null)}else n(null,r)},o.postMessage(s,a),o};return _f})({}),n=Uint8Array,r=Uint16Array,i=Int32Array,e=new n([0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0,0]),o=new n([0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13,0,0]),s=new n([16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15]),a=function(t,n){for(var e=new r(31),o=0;o<31;++o)e[o]=n+=1<>1|(21845&d)<<1;v[d]=((65280&(g=(61680&(g=(52428&g)>>2|(13107&g)<<2))>>4|(3855&g)<<4))>>8|(255&g)<<8)>>1}var y=function(t,n,i){for(var e=t.length,o=0,s=new r(n);o>h]=f}else for(a=new r(e),o=0;o>15-t[o]);return a},m=new n(288);for(d=0;d<144;++d)m[d]=8;for(d=144;d<256;++d)m[d]=9;for(d=256;d<280;++d)m[d]=7;for(d=280;d<288;++d)m[d]=8;var b=new n(32);for(d=0;d<32;++d)b[d]=5;var w=y(m,9,0),x=y(m,9,1),z=y(b,5,0),k=y(b,5,1),M=function(t){for(var n=t[0],r=1;rn&&(n=t[r]);return n},S=function(t,n,r){var i=n/8|0;return(t[i]|t[i+1]<<8)>>(7&n)&r},A=function(t,n){var r=n/8|0;return(t[r]|t[r+1]<<8|t[r+2]<<16)>>(7&n)},T=function(t){return(t+7)/8|0},D=function(t,r,i){return(null==r||r<0)&&(r=0),(null==i||i>t.length)&&(i=t.length),new n(t.subarray(r,i))};_e.FlateErrorCode={UnexpectedEOF:0,InvalidBlockType:1,InvalidLengthLiteral:2,InvalidDistance:3,StreamFinished:4,NoStreamHandler:5,InvalidHeader:6,NoCallback:7,InvalidUTF8:8,ExtraFieldTooLong:9,InvalidDate:10,FilenameTooLong:11,StreamFinishing:12,InvalidZipData:13,UnknownCompressionMethod:14};var C=["unexpected EOF","invalid block type","invalid length/literal","invalid distance","stream finished","no stream handler",,"no callback","invalid UTF-8 data","extra field too long","date not in range 1980-2099","filename too long","stream finishing","invalid zip data"],I=function(t,n,r){var i=Error(n||C[t]);if(i.code=t,Error.captureStackTrace&&Error.captureStackTrace(i,I),!r)throw i;return i},U=function(t,r,i,a){var u=t.length,f=a?a.length:0;if(!u||r.f&&!r.l)return i||new n(0);var c=!i,p=c||2!=r.i,v=r.i;c&&(i=new n(3*u));var d=function(t){var r=i.length;if(t>r){var e=new n(Math.max(2*r,t));e.set(i),i=e}},g=r.f||0,m=r.p||0,b=r.b||0,w=r.l,z=r.d,C=r.m,U=r.n,F=8*u;do{if(!w){g=S(t,m,1);var E=S(t,m+1,3);if(m+=3,!E){var Z=t[(Y=T(m)+4)-4]|t[Y-3]<<8,q=Y+Z;if(q>u){v&&I(0);break}p&&d(b+Z),i.set(t.subarray(Y,q),b),r.b=b+=Z,r.p=m=8*q,r.f=g;continue}if(1==E)w=x,z=k,C=9,U=5;else if(2==E){var O=S(t,m,31)+257,G=S(t,m+10,15)+4,L=O+S(t,m+5,31)+1;m+=14;for(var B=new n(L),H=new n(19),j=0;j>4)<16)B[j++]=Y;else{var K=0,Q=0;for(16==Y?(Q=3+S(t,m,3),m+=2,K=B[j-1]):17==Y?(Q=3+S(t,m,7),m+=3):18==Y&&(Q=11+S(t,m,127),m+=7);Q--;)B[j++]=K}}var R=B.subarray(0,O),W=B.subarray(O);C=M(R),U=M(W),w=y(R,C,1),z=y(W,U,1)}else I(1);if(m>F){v&&I(0);break}}p&&d(b+131072);for(var X=(1<>4;if((m+=15&K)>F){v&&I(0);break}if(K||I(2),tt<256)i[b++]=tt;else{if(256==tt){_=m,w=null;break}var nt=tt-254;tt>264&&(nt=S(t,m,(1<<(et=e[j=tt-257]))-1)+h[j],m+=et);var rt=z[A(t,m)&$],it=rt>>4;if(rt||I(3),m+=15&rt,W=l[it],it>3){var et=o[it];W+=A(t,m)&(1<F){v&&I(0);break}p&&d(b+131072);var ot=b+nt;if(b>8},E=function(t,n,r){var i=n/8|0;t[i]|=r<<=7&n,t[i+1]|=r>>8,t[i+2]|=r>>16},Z=function(t,i){for(var e=[],o=0;ov&&(v=a[o].s);var d=new r(v+1),g=q(e[l-1],d,0);if(g>i){o=0;var y=0,m=g-i,b=1<i))break;y+=b-(1<>=m;y>0;){var x=a[o].s;d[x]=0&&y;--o){var z=a[o].s;d[z]==i&&(--d[z],++y)}g=i}return{t:new n(d),l:g}},q=function(t,n,r){return-1==t.s?Math.max(q(t.l,n,r+1),q(t.r,n,r+1)):n[t.s]=r},O=function(t){for(var n=t.length;n&&!t[--n];);for(var i=new r(++n),e=0,o=t[0],s=1,a=function(t){i[e++]=t},u=1;u<=n;++u)if(t[u]==o&&u!=n)++s;else{if(!o&&s>2){for(;s>138;s-=138)a(32754);s>2&&(a(s>10?s-11<<5|28690:s-3<<5|12305),s=0)}else if(s>3){for(a(o),--s;s>6;s-=6)a(8304);s>2&&(a(s-3<<5|8208),s=0)}for(;s--;)a(o);s=1,o=t[u]}return{c:i.subarray(0,e),n:n}},G=function(t,n){for(var r=0,i=0;i>8,t[e+2]=255^t[e],t[e+3]=255^t[e+1];for(var o=0;o4&&!j[s[P-1]];--P);var V,Y,J,K,Q=p+5<<3,R=G(u,m)+G(h,b)+f,W=G(u,g)+G(h,M)+f+14+3*P+G(q,j)+2*q[16]+3*q[17]+7*q[18];if(l>=0&&Q<=R&&Q<=W)return L(n,v,t.subarray(l,l+p));if(F(n,v,1+(W15&&(F(n,v,tt[B]>>5&127),v+=tt[B]>>12)}}else V=w,Y=m,J=z,K=b;for(B=0;B255){var rt;E(n,v,V[257+(rt=nt>>18&31)]),v+=Y[rt+257],rt>7&&(F(n,v,nt>>23&31),v+=e[rt]);var it=31&nt;E(n,v,J[it]),v+=K[it],it>3&&(E(n,v,nt>>5&8191),v+=o[it])}else E(n,v,V[nt]),v+=Y[nt]}return E(n,v,V[256]),v+Y[256]},H=new i([65540,131080,131088,131104,262176,1048704,1048832,2114560,2117632]),j=new n(0),N=function(t,s,a,u,h,c){var l=c.z||t.length,v=new n(u+l+5*(1+Math.ceil(l/7e3))+h),d=v.subarray(u,v.length-h),g=c.l,y=7&(c.r||0);if(s){y&&(d[0]=c.r>>3);for(var m=H[s-1],b=m>>13,w=8191&m,x=(1<7e3||q>24576)&&(V>423||!g)){y=B(t,d,0,C,I,U,E,q,G,Z-G,y),q=F=E=0,G=Z;for(var Y=0;Y<286;++Y)I[Y]=0;for(Y=0;Y<30;++Y)U[Y]=0}var J=2,K=0,Q=w,R=N-P&32767;if(V>2&&j==A(Z-R))for(var W=Math.min(b,V)-1,X=Math.min(32767,Z),$=Math.min(258,V);R<=X&&--Q&&N!=P;){if(t[Z+J]==t[Z+J-R]){for(var _=0;_<$&&t[Z+_]==t[Z+_-R];++_);if(_>J){if(J=_,K=R,_>W)break;var tt=Math.min(R,_-2),nt=0;for(Y=0;Ynt&&(nt=it,P=rt)}}}R+=(N=P)-(P=z[N])&32767}if(K){C[q++]=268435456|f[J]<<18|p[K];var et=31&f[J],ot=31&p[K];E+=e[et]+o[ot],++I[257+et],++U[ot],O=Z+J,++F}else C[q++]=t[Z],++I[t[Z]]}}for(Z=Math.max(Z,O);Z=l&&(d[y/8|0]=g,st=l),y=L(d,y+1,t.subarray(Z,st))}c.i=l}return D(v,0,u+T(y)+h)},P=function(){for(var t=new Int32Array(256),n=0;n<256;++n){for(var r=n,i=9;--i;)r=(1&r&&-306674912)^r>>>1;t[n]=r}return t}(),V=function(){var t=-1;return{p:function(n){for(var r=t,i=0;i>>8;t=r},d:function(){return~t}}},Y=function(){var t=1,n=0;return{p:function(r){for(var i=t,e=n,o=0|r.length,s=0;s!=o;){for(var a=Math.min(s+2655,o);s>16),e=(65535&e)+15*(e>>16)}t=i,n=e},d:function(){return(255&(t%=65521))<<24|(65280&t)<<8|(255&(n%=65521))<<8|n>>8}}},J=function(t,r,i,e,o){if(!o&&(o={l:1},r.dictionary)){var s=r.dictionary.subarray(-32768),a=new n(s.length+t.length);a.set(s),a.set(t,s.length),t=a,o.w=s.length}return N(t,null==r.level?6:r.level,null==r.mem?o.l?Math.ceil(1.5*Math.max(8,Math.min(13,Math.log(t.length)))):20:12+r.mem,i,e,o)},K=function(t,n){var r={};for(var i in t)r[i]=t[i];for(var i in n)r[i]=n[i];return r},Q=function(t,n,r){for(var i=t(),e=""+t,o=e.slice(e.indexOf("[")+1,e.lastIndexOf("]")).replace(/\s+/g,"").split(","),s=0;s>>0},ct=function(t,n){return ft(t,n)+4294967296*ft(t,n+4)},lt=function(t,n,r){for(;r;++n)t[n]=r,r>>>=8},pt=function(t,n){var r=n.filename;if(t[0]=31,t[1]=139,t[2]=8,t[8]=n.level<2?4:9==n.level?2:0,t[9]=3,0!=n.mtime&<(t,4,Math.floor(new Date(n.mtime||Date.now())/1e3)),r){t[3]=8;for(var i=0;i<=r.length;++i)t[i+10]=r.charCodeAt(i)}},vt=function(t){31==t[0]&&139==t[1]&&8==t[2]||I(6,"invalid gzip data");var n=t[3],r=10;4&n&&(r+=2+(t[10]|t[11]<<8));for(var i=(n>>3&1)+(n>>4&1);i>0;i-=!t[r++]);return r+(2&n)},dt=function(t){var n=t.length;return(t[n-4]|t[n-3]<<8|t[n-2]<<16|t[n-1]<<24)>>>0},gt=function(t){return 10+(t.filename?t.filename.length+1:0)},yt=function(t,n){var r=n.level,i=0==r?0:r<6?1:9==r?3:2;if(t[0]=120,t[1]=i<<6|(n.dictionary&&32),t[1]|=31-(t[0]<<8|t[1])%31,n.dictionary){var e=Y();e.p(n.dictionary),lt(t,2,e.d())}},mt=function(t,n){return(8!=(15&t[0])||t[0]>>4>7||(t[0]<<8|t[1])%31)&&I(6,"invalid zlib data"),(t[1]>>5&1)==+!n&&I(6,"invalid zlib data: "+(32&t[1]?"need":"unexpected")+" dictionary"),2+(t[1]>>3&4)};function bt(t,n){return"function"==typeof t&&(n=t,t={}),this.ondata=n,t}var wt=function(){function t(t,r){if("function"==typeof t&&(r=t,t={}),this.ondata=r,this.o=t||{},this.s={l:0,i:32768,w:32768,z:32768},this.b=new n(98304),this.o.dictionary){var i=this.o.dictionary.subarray(-32768);this.b.set(i,32768-i.length),this.s.i=32768-i.length}}return t.prototype.p=function(t,n){this.ondata(J(t,this.o,0,0,this.s),n)},t.prototype.push=function(t,r){this.ondata||I(5),this.s.l&&I(4);var i=t.length+this.s.z;if(i>this.b.length){if(i>2*this.b.length-32768){var e=new n(-32768&i);e.set(this.b.subarray(0,this.s.z)),this.b=e}var o=this.b.length-this.s.z;this.b.set(t.subarray(0,o),this.s.z),this.s.z=this.b.length,this.p(this.b,!1),this.b.set(this.b.subarray(-32768)),this.b.set(t.subarray(o),32768),this.s.z=t.length-o+32768,this.s.i=32766,this.s.w=32768}else this.b.set(t,this.s.z),this.s.z+=t.length;this.s.l=1&r,(this.s.z>this.s.w+8191||r)&&(this.p(this.b,r||!1),this.s.w=this.s.i,this.s.i-=2),r&&(this.s=this.o={},this.b=j)},t.prototype.flush=function(t){if(this.ondata||I(5),this.s.l&&I(4),this.p(this.b,!1),this.s.w=this.s.i,this.s.i-=2,t){var r=new n(6);r[0]=this.s.r>>3;var i=L(r,this.s.r,j);this.s.r=0,this.ondata(r.subarray(0,i>>3),!1)}},t}();_e.Deflate=wt;var xt=function(){return function(t,n){ut([_,function(){return[at,wt]}],this,bt.call(this,t,n),function(t){var n=new wt(t.data);onmessage=at(n)},6,1)}}();function zt(t,n,r){return r||(r=n,n={}),"function"!=typeof r&&I(7),st(t,n,[_],function(t){return et(kt(t.data[0],t.data[1]))},0,r)}function kt(t,n){return J(t,n||{},0,0)}_e.AsyncDeflate=xt;var Mt=function(){function t(t,r){"function"==typeof t&&(r=t,t={}),this.ondata=r;var i=t&&t.dictionary&&t.dictionary.subarray(-32768);this.s={i:0,b:i?i.length:0},this.o=new n(32768),this.p=new n(0),i&&this.o.set(i)}return t.prototype.e=function(t){if(this.ondata||I(5),this.d&&I(4),this.p.length){if(t.length){var r=new n(this.p.length+t.length);r.set(this.p),r.set(t,this.p.length),this.p=r}}else this.p=t},t.prototype.c=function(t){this.s.i=+(this.d=t||!1);var n=this.s.b,r=U(this.p,this.s,this.o);this.ondata(D(r,n,this.s.b),this.d),this.o=D(r,this.s.b-32768),this.s.b=this.o.length,this.p=D(this.p,this.s.p/8|0),this.s.p&=7},t.prototype.push=function(t,n){this.e(t),this.c(n)},t}();_e.Inflate=Mt;var St=function(){return function(t,n){ut([$,function(){return[at,Mt]}],this,bt.call(this,t,n),function(t){var n=new Mt(t.data);onmessage=at(n)},7,0)}}();function At(t,n,r){return r||(r=n,n={}),"function"!=typeof r&&I(7),st(t,n,[$],function(t){return et(Tt(t.data[0],ot(t.data[1])))},1,r)}function Tt(t,n){return U(t,{i:2},n&&n.out,n&&n.dictionary)}_e.AsyncInflate=St;var Dt=function(){function t(t,n){this.c=V(),this.l=0,this.v=1,wt.call(this,t,n)}return t.prototype.push=function(t,n){this.c.p(t),this.l+=t.length,wt.prototype.push.call(this,t,n)},t.prototype.p=function(t,n){var r=J(t,this.o,this.v&>(this.o),n&&8,this.s);this.v&&(pt(r,this.o),this.v=0),n&&(lt(r,r.length-8,this.c.d()),lt(r,r.length-4,this.l)),this.ondata(r,n)},t.prototype.flush=function(t){wt.prototype.flush.call(this,t)},t}();_e.Gzip=Dt,_e.Compress=Dt;var Ct=function(){return function(t,n){ut([_,tt,function(){return[at,wt,Dt]}],this,bt.call(this,t,n),function(t){var n=new Dt(t.data);onmessage=at(n)},8,1)}}();function It(t,n,r){return r||(r=n,n={}),"function"!=typeof r&&I(7),st(t,n,[_,tt,function(){return[Ut]}],function(t){return et(Ut(t.data[0],t.data[1]))},2,r)}function Ut(t,n){n||(n={});var r=V(),i=t.length;r.p(t);var e=J(t,n,gt(n),8),o=e.length;return pt(e,n),lt(e,o-8,r.d()),lt(e,o-4,i),e}_e.AsyncGzip=Ct,_e.AsyncCompress=Ct;var Ft=function(){function t(t,n){this.v=1,this.r=0,Mt.call(this,t,n)}return t.prototype.push=function(t,r){if(Mt.prototype.e.call(this,t),this.r+=t.length,this.v){var i=this.p.subarray(this.v-1),e=i.length>3?vt(i):4;if(e>i.length){if(!r)return}else this.v>1&&this.onmember&&this.onmember(this.r-i.length);this.p=i.subarray(e),this.v=0}Mt.prototype.c.call(this,0),this.s.f&&!this.s.l?(this.v=T(this.s.p)+9,this.s={i:0},this.o=new n(0),this.push(new n(0),r)):r&&Mt.prototype.c.call(this,r)},t}();_e.Gunzip=Ft;var Et=function(){return function(t,n){var r=this;ut([$,nt,function(){return[at,Mt,Ft]}],this,bt.call(this,t,n),function(t){var n=new Ft(t.data);n.onmember=function(t){return postMessage(t)},onmessage=at(n)},9,0,function(t){return r.onmember&&r.onmember(t)})}}();function Zt(t,n,r){return r||(r=n,n={}),"function"!=typeof r&&I(7),st(t,n,[$,nt,function(){return[qt]}],function(t){return et(qt(t.data[0],t.data[1]))},3,r)}function qt(t,r){var i=vt(t);return i+8>t.length&&I(6,"invalid gzip data"),U(t.subarray(i,-8),{i:2},r&&r.out||new n(dt(t)),r&&r.dictionary)}_e.AsyncGunzip=Et;var Ot=function(){function t(t,n){this.c=Y(),this.v=1,wt.call(this,t,n)}return t.prototype.push=function(t,n){this.c.p(t),wt.prototype.push.call(this,t,n)},t.prototype.p=function(t,n){var r=J(t,this.o,this.v&&(this.o.dictionary?6:2),n&&4,this.s);this.v&&(yt(r,this.o),this.v=0),n&<(r,r.length-4,this.c.d()),this.ondata(r,n)},t.prototype.flush=function(t){wt.prototype.flush.call(this,t)},t}();_e.Zlib=Ot;var Gt=function(){return function(t,n){ut([_,rt,function(){return[at,wt,Ot]}],this,bt.call(this,t,n),function(t){var n=new Ot(t.data);onmessage=at(n)},10,1)}}();function Lt(t,n,r){return r||(r=n,n={}),"function"!=typeof r&&I(7),st(t,n,[_,rt,function(){return[Bt]}],function(t){return et(Bt(t.data[0],t.data[1]))},4,r)}function Bt(t,n){n||(n={});var r=Y();r.p(t);var i=J(t,n,n.dictionary?6:2,4);return yt(i,n),lt(i,i.length-4,r.d()),i}_e.AsyncZlib=Gt;var Ht=function(){function t(t,n){Mt.call(this,t,n),this.v=t&&t.dictionary?2:1}return t.prototype.push=function(t,n){if(Mt.prototype.e.call(this,t),this.v){if(this.p.length<6&&!n)return;this.p=this.p.subarray(mt(this.p,this.v-1)),this.v=0}n&&(this.p.length<4&&I(6,"invalid zlib data"),this.p=this.p.subarray(0,-4)),Mt.prototype.c.call(this,n)},t}();_e.Unzlib=Ht;var jt=function(){return function(t,n){ut([$,it,function(){return[at,Mt,Ht]}],this,bt.call(this,t,n),function(t){var n=new Ht(t.data);onmessage=at(n)},11,0)}}();function Nt(t,n,r){return r||(r=n,n={}),"function"!=typeof r&&I(7),st(t,n,[$,it,function(){return[Pt]}],function(t){return et(Pt(t.data[0],ot(t.data[1])))},5,r)}function Pt(t,n){return U(t.subarray(mt(t,n&&n.dictionary),-4),{i:2},n&&n.out,n&&n.dictionary)}_e.AsyncUnzlib=jt;var Vt=function(){function t(t,n){this.o=bt.call(this,t,n)||{},this.G=Ft,this.I=Mt,this.Z=Ht}return t.prototype.i=function(){var t=this;this.s.ondata=function(n,r){t.ondata(n,r)}},t.prototype.push=function(t,r){if(this.ondata||I(5),this.s)this.s.push(t,r);else{if(this.p&&this.p.length){var i=new n(this.p.length+t.length);i.set(this.p),i.set(t,this.p.length)}else this.p=t;this.p.length>2&&(this.s=31==this.p[0]&&139==this.p[1]&&8==this.p[2]?new this.G(this.o):8!=(15&this.p[0])||this.p[0]>>4>7||(this.p[0]<<8|this.p[1])%31?new this.I(this.o):new this.Z(this.o),this.i(),this.s.push(this.p,r),this.p=null)}},t}();_e.Decompress=Vt;var Yt=function(){function t(t,n){Vt.call(this,t,n),this.queuedSize=0,this.G=Et,this.I=St,this.Z=jt}return t.prototype.i=function(){var t=this;this.s.ondata=function(n,r,i){t.ondata(n,r,i)},this.s.ondrain=function(n){t.queuedSize-=n,t.ondrain&&t.ondrain(n)}},t.prototype.push=function(t,n){this.queuedSize+=t.length,Vt.prototype.push.call(this,t,n)},t}();function Jt(t,n,r){return r||(r=n,n={}),"function"!=typeof r&&I(7),31==t[0]&&139==t[1]&&8==t[2]?Zt(t,n,r):8!=(15&t[0])||t[0]>>4>7||(t[0]<<8|t[1])%31?At(t,n,r):Nt(t,n,r)}function Kt(t,n){return 31==t[0]&&139==t[1]&&8==t[2]?qt(t,n):8!=(15&t[0])||t[0]>>4>7||(t[0]<<8|t[1])%31?Tt(t,n):Pt(t,n)}_e.AsyncDecompress=Yt;var Qt=function(t,r,i,e){for(var o in t){var s=t[o],a=r+o,u=e;Array.isArray(s)&&(u=K(e,s[1]),s=s[0]),ArrayBuffer.isView(s)?i[a]=[s,u]:(i[a+="/"]=[new n(0),u],Qt(s,a,i,e))}},Rt="undefined"!=typeof TextEncoder&&new TextEncoder,Wt="undefined"!=typeof TextDecoder&&new TextDecoder,Xt=0;try{Wt.decode(j,{stream:!0}),Xt=1}catch(t){}var $t=function(t){for(var n="",r=0;;){var i=t[r++],e=(i>127)+(i>223)+(i>239);if(r+e>t.length)return{s:n,r:D(t,r-1)};e?3==e?(i=((15&i)<<18|(63&t[r++])<<12|(63&t[r++])<<6|63&t[r++])-65536,n+=String.fromCharCode(55296|i>>10,56320|1023&i)):n+=String.fromCharCode(1&e?(31&i)<<6|63&t[r++]:(15&i)<<12|(63&t[r++])<<6|63&t[r++]):n+=String.fromCharCode(i)}},_t=function(){function t(t){this.ondata=t,Xt?this.t=new TextDecoder:this.p=j}return t.prototype.push=function(t,r){if(this.ondata||I(5),r=!!r,this.t)return this.ondata(this.t.decode(t,{stream:!0}),r),void(r&&(this.t.decode().length&&I(8),this.t=null));this.p||I(4);var i=new n(this.p.length+t.length);i.set(this.p),i.set(t,this.p.length);var e=$t(i),o=e.s,s=e.r;r?(s.length&&I(8),this.p=null):this.p=s,this.ondata(o,r)},t}();_e.DecodeUTF8=_t;var tn=function(){function t(t){this.ondata=t}return t.prototype.push=function(t,n){this.ondata||I(5),this.d&&I(4),this.ondata(nn(t),this.d=n||!1)},t}();function nn(t,r){if(r){for(var i=new n(t.length),e=0;e>1)),a=0,u=function(t){s[a++]=t};for(e=0;es.length){var h=new n(a+8+(o-e<<1));h.set(s),s=h}var f=t.charCodeAt(e);f<128||r?u(f):f<2048?(u(192|f>>6),u(128|63&f)):f>55295&&f<57344?(u(240|(f=65536+(1047552&f)|1023&t.charCodeAt(++e))>>18),u(128|f>>12&63),u(128|f>>6&63),u(128|63&f)):(u(224|f>>12),u(128|f>>6&63),u(128|63&f))}return D(s,0,a)}function rn(t,n){if(n){for(var r="",i=0;i65535&&I(9),n+=i+4}return n},hn=function(t,n,r,i,e,o,s,a){var u=i.length,h=r.extra,f=a&&a.length,c=un(h);lt(t,n,null!=s?33639248:67324752),n+=4,null!=s&&(t[n++]=20,t[n++]=r.os),t[n]=20,n+=2,t[n++]=r.flag<<1|(o<0&&8),t[n++]=e&&8,t[n++]=255&r.compression,t[n++]=r.compression>>8;var l=new Date(null==r.mtime?Date.now():r.mtime),p=l.getFullYear()-1980;if((p<0||p>119)&&I(10),lt(t,n,p<<25|l.getMonth()+1<<21|l.getDate()<<16|l.getHours()<<11|l.getMinutes()<<5|l.getSeconds()>>1),n+=4,-1!=o&&(lt(t,n,r.crc),lt(t,n+4,o<0?-o-2:o),lt(t,n+8,r.size)),lt(t,n+12,u),lt(t,n+14,c),n+=16,null!=s&&(lt(t,n,f),lt(t,n+6,r.attrs),lt(t,n+10,s),n+=14),t.set(i,n),n+=u,c)for(var v in h){var d=h[v],g=d.length;lt(t,n,+v),lt(t,n+2,g),t.set(d,n+4),n+=4+g}return f&&(t.set(a,n),n+=f),n},fn=function(t,n,r,i,e){lt(t,n,101010256),lt(t,n+8,r),lt(t,n+10,r),lt(t,n+12,i),lt(t,n+16,e)},cn=function(){function t(t){this.filename=t,this.c=V(),this.size=0,this.compression=0}return t.prototype.process=function(t,n){this.ondata(null,t,n)},t.prototype.push=function(t,n){this.ondata||I(5),this.c.p(t),this.size+=t.length,n&&(this.crc=this.c.d()),this.process(t,n||!1)},t}();_e.ZipPassThrough=cn;var ln=function(){function t(t,n){var r=this;n||(n={}),cn.call(this,t),this.d=new wt(n,function(t,n){r.ondata(null,t,n)}),this.compression=8,this.flag=en(n.level)}return t.prototype.process=function(t,n){try{this.d.push(t,n)}catch(t){this.ondata(t,null,n)}},t.prototype.push=function(t,n){cn.prototype.push.call(this,t,n)},t}();_e.ZipDeflate=ln;var pn=function(){function t(t,n){var r=this;n||(n={}),cn.call(this,t),this.d=new xt(n,function(t,n,i){r.ondata(t,n,i)}),this.compression=8,this.flag=en(n.level),this.terminate=this.d.terminate}return t.prototype.process=function(t,n){this.d.push(t,n)},t.prototype.push=function(t,n){cn.prototype.push.call(this,t,n)},t}();_e.AsyncZipDeflate=pn;var vn=function(){function t(t){this.ondata=t,this.u=[],this.d=1}return t.prototype.add=function(t){var r=this;if(this.ondata||I(5),2&this.d)this.ondata(I(4+8*(1&this.d),0,1),null,!1);else{var i=nn(t.filename),e=i.length,o=t.comment,s=o&&nn(o),a=e!=t.filename.length||s&&o.length!=s.length,u=e+un(t.extra)+30;e>65535&&this.ondata(I(11,0,1),null,!1);var h=new n(u);hn(h,0,t,i,a,-1);var f=[h],c=function(){for(var t=0,n=f;t65535&&M(I(11,0,1),null),k)if(g<16e4)try{M(null,kt(i,h))}catch(t){M(t,null)}else c.push(zt(i,h,M));else M(null,i)},g=0;g65535&&I(11);var y=c?kt(h,f):h,m=y.length,b=V();b.p(h),e.push(K(f,{size:h.length,crc:b.d(),c:y,f:M,m:v,u:l!=a.length||v&&p.length!=d,o:o,compression:c})),o+=30+l+g+m,s+=76+2*(l+g)+(d||0)+m}for(var w=new n(s+22),x=o,z=s-o,k=0;k0){var e=Math.min(this.c,t.length),o=t.subarray(0,e);if(this.c-=e,this.d?this.d.push(o,!this.c):this.k[0].push(o),(t=t.subarray(e)).length)return this.push(t,r)}else{var s=0,a=0,u=void 0,h=void 0;this.p.length?t.length?((h=new n(this.p.length+t.length)).set(this.p),h.set(t,this.p.length)):h=this.p:h=t;for(var f=h.length,c=this.c,l=c&&this.d,p=function(){var t=ft(h,a);if(67324752==t){s=1,u=a,v.d=null,v.c=0;var n=ht(h,a+6),r=ht(h,a+8),e=2048&n,o=8&n,l=ht(h,a+26),p=ht(h,a+28);if(f>a+30+l+p){var d=[];v.k.unshift(d),s=2;var g,y=ft(h,a+18),m=ft(h,a+22),b=rn(h.subarray(a+30,a+=30+l),!e),w=an(h,a,p,2,y,m,0),x=w[0],z=w[1];o&&(x=-1-w[3]),a+=p,v.c=x;var k={name:b,compression:r,start:function(){if(k.ondata||I(5),x){var t=i.o[r];t||k.ondata(I(14,"unknown compression type "+r,1),null,!1),(g=x<0?new t(b):new t(b,x,z)).ondata=function(t,n,r){k.ondata(t,n,r)};for(var n=0,e=d;n=0&&(k.size=x,k.originalSize=z),v.onfile(k)}return"break"}if(c){if(134695760==t)return u=a+=12+(-2==c&&8),s=3,v.c=0,"break";if(33639248==t)return u=a-=4,s=3,v.c=0,"break"}},v=this;a65558)return a(I(13,0,1),null),o;var h=ht(t,u+8);if(h){var f=h,c=ft(t,u+16),l=117853008==ft(t,u-20);if(l){var p=ft(t,u-12);(l=101075792==ft(t,p))&&(f=h=ft(t,p+32),c=ft(t,p+48))}for(var v=r&&r.filter,d=function(r){var i=sn(t,c,l),u=i[0],f=i[1],p=i[2],d=i[3],g=i[4],y=on(t,i[5]);c=g;var m=function(t,n){t?(o(),a(t,null)):(n&&(s[d]=n),--h||a(null,s))};if(!v||v({name:d,size:f,originalSize:p,compression:u}))if(u)if(8==u){var b=t.subarray(y,y+f);if(p<524288||f>.8*p)try{m(null,Tt(b,{out:new n(p)}))}catch(t){m(t,null)}else e.push(At(b,{size:p},m))}else m(I(14,"unknown compression type "+u,1),null);else m(null,D(t,y,y+f));else m(null,null)},g=0;g65558)&&I(13);var o=ht(t,e+8);if(!o)return{};var s=ft(t,e+16),a=117853008==ft(t,e-20);if(a){var u=ft(t,e-12);(a=101075792==ft(t,u))&&(o=ft(t,u+32),s=ft(t,u+48))}for(var h=r&&r.filter,f=0;f Super simple cache for file metadata, useful for process that work on a given series of files +> and that only need to repeat the job on the changed ones since the previous run of the process — Edit + +[![NPM Version](https://img.shields.io/npm/v/file-entry-cache.svg?style=flat)](https://npmjs.org/package/file-entry-cache) +[![tests](https://github.com/jaredwray/file-entry-cache/actions/workflows/tests.yaml/badge.svg?branch=master)](https://github.com/jaredwray/file-entry-cache/actions/workflows/tests.yaml) +[![codecov](https://codecov.io/github/jaredwray/file-entry-cache/graph/badge.svg?token=37tZMQE0Sy)](https://codecov.io/github/jaredwray/file-entry-cache) +[![npm](https://img.shields.io/npm/dm/file-entry-cache)](https://npmjs.com/package/file-entry-cache) + + +## install + +```bash +npm i --save file-entry-cache +``` + +## Usage + +The module exposes two functions `create` and `createFromFile`. + +## `create(cacheName, [directory, useCheckSum])` +- **cacheName**: the name of the cache to be created +- **directory**: Optional the directory to load the cache from +- **usecheckSum**: Whether to use md5 checksum to verify if file changed. If false the default will be to use the mtime and size of the file. + +## `createFromFile(pathToCache, [useCheckSum])` +- **pathToCache**: the path to the cache file (this combines the cache name and directory) +- **useCheckSum**: Whether to use md5 checksum to verify if file changed. If false the default will be to use the mtime and size of the file. + +```js +// loads the cache, if one does not exists for the given +// Id a new one will be prepared to be created +var fileEntryCache = require('file-entry-cache'); + +var cache = fileEntryCache.create('testCache'); + +var files = expand('../fixtures/*.txt'); + +// the first time this method is called, will return all the files +var oFiles = cache.getUpdatedFiles(files); + +// this will persist this to disk checking each file stats and +// updating the meta attributes `size` and `mtime`. +// custom fields could also be added to the meta object and will be persisted +// in order to retrieve them later +cache.reconcile(); + +// use this if you want the non visited file entries to be kept in the cache +// for more than one execution +// +// cache.reconcile( true /* noPrune */) + +// on a second run +var cache2 = fileEntryCache.create('testCache'); + +// will return now only the files that were modified or none +// if no files were modified previous to the execution of this function +var oFiles = cache.getUpdatedFiles(files); + +// if you want to prevent a file from being considered non modified +// something useful if a file failed some sort of validation +// you can then remove the entry from the cache doing +cache.removeEntry('path/to/file'); // path to file should be the same path of the file received on `getUpdatedFiles` +// that will effectively make the file to appear again as modified until the validation is passed. In that +// case you should not remove it from the cache + +// if you need all the files, so you can determine what to do with the changed ones +// you can call +var oFiles = cache.normalizeEntries(files); + +// oFiles will be an array of objects like the following +entry = { + key: 'some/name/file', the path to the file + changed: true, // if the file was changed since previous run + meta: { + size: 3242, // the size of the file + mtime: 231231231, // the modification time of the file + data: {} // some extra field stored for this file (useful to save the result of a transformation on the file + } +} + +``` + +## Motivation for this module + +I needed a super simple and dumb **in-memory cache** with optional disk persistence (write-back cache) in order to make +a script that will beautify files with `esformatter` to execute only on the files that were changed since the last run. + +In doing so the process of beautifying files was reduced from several seconds to a small fraction of a second. + +This module uses [flat-cache](https://www.npmjs.com/package/flat-cache) a super simple `key/value` cache storage with +optional file persistance. + +The main idea is to read the files when the task begins, apply the transforms required, and if the process succeed, +then store the new state of the files. The next time this module request for `getChangedFiles` will return only +the files that were modified. Making the process to end faster. + +This module could also be used by processes that modify the files applying a transform, in that case the result of the +transform could be stored in the `meta` field, of the entries. Anything added to the meta field will be persisted. +Those processes won't need to call `getChangedFiles` they will instead call `normalizeEntries` that will return the +entries with a `changed` field that can be used to determine if the file was changed or not. If it was not changed +the transformed stored data could be used instead of actually applying the transformation, saving time in case of only +a few files changed. + +In the worst case scenario all the files will be processed. In the best case scenario only a few of them will be processed. + +## Important notes +- The values set on the meta attribute of the entries should be `stringify-able` ones if possible, flat-cache uses `circular-json` to try to persist circular structures, but this should be considered experimental. The best results are always obtained with non circular values +- All the changes to the cache state are done to memory first and only persisted after reconcile. + +## License + +MIT + + diff --git a/tools/ui/node_modules/file-entry-cache/cache.js b/tools/ui/node_modules/file-entry-cache/cache.js new file mode 100644 index 0000000000000000000000000000000000000000..6b15767e164f4e8c3e6d6685daf42cd75130e485 --- /dev/null +++ b/tools/ui/node_modules/file-entry-cache/cache.js @@ -0,0 +1,291 @@ +var path = require('path'); +var crypto = require('crypto'); + +module.exports = { + createFromFile: function (filePath, useChecksum) { + var fname = path.basename(filePath); + var dir = path.dirname(filePath); + return this.create(fname, dir, useChecksum); + }, + + create: function (cacheId, _path, useChecksum) { + var fs = require('fs'); + var flatCache = require('flat-cache'); + var cache = flatCache.load(cacheId, _path); + var normalizedEntries = {}; + + var removeNotFoundFiles = function removeNotFoundFiles() { + const cachedEntries = cache.keys(); + // remove not found entries + cachedEntries.forEach(function remover(fPath) { + try { + fs.statSync(fPath); + } catch (err) { + if (err.code === 'ENOENT') { + cache.removeKey(fPath); + } + } + }); + }; + + removeNotFoundFiles(); + + return { + /** + * the flat cache storage used to persist the metadata of the `files + * @type {Object} + */ + cache: cache, + + /** + * Given a buffer, calculate md5 hash of its content. + * @method getHash + * @param {Buffer} buffer buffer to calculate hash on + * @return {String} content hash digest + */ + getHash: function (buffer) { + return crypto.createHash('md5').update(buffer).digest('hex'); + }, + + /** + * Return whether or not a file has changed since last time reconcile was called. + * @method hasFileChanged + * @param {String} file the filepath to check + * @return {Boolean} wheter or not the file has changed + */ + hasFileChanged: function (file) { + return this.getFileDescriptor(file).changed; + }, + + /** + * given an array of file paths it return and object with three arrays: + * - changedFiles: Files that changed since previous run + * - notChangedFiles: Files that haven't change + * - notFoundFiles: Files that were not found, probably deleted + * + * @param {Array} files the files to analyze and compare to the previous seen files + * @return {[type]} [description] + */ + analyzeFiles: function (files) { + var me = this; + files = files || []; + + var res = { + changedFiles: [], + notFoundFiles: [], + notChangedFiles: [], + }; + + me.normalizeEntries(files).forEach(function (entry) { + if (entry.changed) { + res.changedFiles.push(entry.key); + return; + } + if (entry.notFound) { + res.notFoundFiles.push(entry.key); + return; + } + res.notChangedFiles.push(entry.key); + }); + return res; + }, + + getFileDescriptor: function (file) { + var fstat; + + try { + fstat = fs.statSync(file); + } catch (ex) { + this.removeEntry(file); + return { key: file, notFound: true, err: ex }; + } + + if (useChecksum) { + return this._getFileDescriptorUsingChecksum(file); + } + + return this._getFileDescriptorUsingMtimeAndSize(file, fstat); + }, + + _getFileDescriptorUsingMtimeAndSize: function (file, fstat) { + var meta = cache.getKey(file); + var cacheExists = !!meta; + + var cSize = fstat.size; + var cTime = fstat.mtime.getTime(); + + var isDifferentDate; + var isDifferentSize; + + if (!meta) { + meta = { size: cSize, mtime: cTime }; + } else { + isDifferentDate = cTime !== meta.mtime; + isDifferentSize = cSize !== meta.size; + } + + var nEntry = (normalizedEntries[file] = { + key: file, + changed: !cacheExists || isDifferentDate || isDifferentSize, + meta: meta, + }); + + return nEntry; + }, + + _getFileDescriptorUsingChecksum: function (file) { + var meta = cache.getKey(file); + var cacheExists = !!meta; + + var contentBuffer; + try { + contentBuffer = fs.readFileSync(file); + } catch (ex) { + contentBuffer = ''; + } + + var isDifferent = true; + var hash = this.getHash(contentBuffer); + + if (!meta) { + meta = { hash: hash }; + } else { + isDifferent = hash !== meta.hash; + } + + var nEntry = (normalizedEntries[file] = { + key: file, + changed: !cacheExists || isDifferent, + meta: meta, + }); + + return nEntry; + }, + + /** + * Return the list o the files that changed compared + * against the ones stored in the cache + * + * @method getUpdated + * @param files {Array} the array of files to compare against the ones in the cache + * @returns {Array} + */ + getUpdatedFiles: function (files) { + var me = this; + files = files || []; + + return me + .normalizeEntries(files) + .filter(function (entry) { + return entry.changed; + }) + .map(function (entry) { + return entry.key; + }); + }, + + /** + * return the list of files + * @method normalizeEntries + * @param files + * @returns {*} + */ + normalizeEntries: function (files) { + files = files || []; + + var me = this; + var nEntries = files.map(function (file) { + return me.getFileDescriptor(file); + }); + + //normalizeEntries = nEntries; + return nEntries; + }, + + /** + * Remove an entry from the file-entry-cache. Useful to force the file to still be considered + * modified the next time the process is run + * + * @method removeEntry + * @param entryName + */ + removeEntry: function (entryName) { + delete normalizedEntries[entryName]; + cache.removeKey(entryName); + }, + + /** + * Delete the cache file from the disk + * @method deleteCacheFile + */ + deleteCacheFile: function () { + cache.removeCacheFile(); + }, + + /** + * remove the cache from the file and clear the memory cache + */ + destroy: function () { + normalizedEntries = {}; + cache.destroy(); + }, + + _getMetaForFileUsingCheckSum: function (cacheEntry) { + var contentBuffer = fs.readFileSync(cacheEntry.key); + var hash = this.getHash(contentBuffer); + var meta = Object.assign(cacheEntry.meta, { hash: hash }); + delete meta.size; + delete meta.mtime; + return meta; + }, + + _getMetaForFileUsingMtimeAndSize: function (cacheEntry) { + var stat = fs.statSync(cacheEntry.key); + var meta = Object.assign(cacheEntry.meta, { + size: stat.size, + mtime: stat.mtime.getTime(), + }); + delete meta.hash; + return meta; + }, + + /** + * Sync the files and persist them to the cache + * @method reconcile + */ + reconcile: function (noPrune) { + removeNotFoundFiles(); + + noPrune = typeof noPrune === 'undefined' ? true : noPrune; + + var entries = normalizedEntries; + var keys = Object.keys(entries); + + if (keys.length === 0) { + return; + } + + var me = this; + + keys.forEach(function (entryName) { + var cacheEntry = entries[entryName]; + + try { + var meta = useChecksum + ? me._getMetaForFileUsingCheckSum(cacheEntry) + : me._getMetaForFileUsingMtimeAndSize(cacheEntry); + cache.setKey(entryName, meta); + } catch (err) { + // if the file does not exists we don't save it + // other errors are just thrown + if (err.code !== 'ENOENT') { + throw err; + } + } + }); + + cache.save(noPrune); + }, + }; + }, +}; diff --git a/tools/ui/node_modules/file-entry-cache/package.json b/tools/ui/node_modules/file-entry-cache/package.json new file mode 100644 index 0000000000000000000000000000000000000000..ef63b6ff8711357d96f4c356bae8e83f19c5c9a5 --- /dev/null +++ b/tools/ui/node_modules/file-entry-cache/package.json @@ -0,0 +1,56 @@ +{ + "name": "file-entry-cache", + "version": "8.0.0", + "description": "Super simple cache for file metadata, useful for process that work o a given series of files and that only need to repeat the job on the changed ones since the previous run of the process", + "repository": "jaredwray/file-entry-cache", + "license": "MIT", + "author": { + "name": "Jared Wray", + "url": "https://jaredwray.com" + }, + "main": "cache.js", + "files": [ + "cache.js" + ], + "engines": { + "node": ">=16.0.0" + }, + "scripts": { + "eslint": "eslint --cache --cache-location=node_modules/.cache/ 'cache.js' 'test/**/*.js' 'perf.js'", + "autofix": "npm run eslint -- --fix", + "clean": "rimraf ./node_modules ./package-lock.json ./yarn.lock", + "test": "npm run eslint --silent && c8 mocha -R spec test/specs", + "test:ci": "npm run eslint --silent && c8 --reporter=lcov mocha -R spec test/specs", + "perf": "node perf.js" + }, + "prepush": [ + "npm run eslint --silent" + ], + "precommit": [ + "npm run eslint --silent" + ], + "keywords": [ + "file cache", + "task cache files", + "file cache", + "key par", + "key value", + "cache" + ], + "devDependencies": { + "c8": "^8.0.1", + "chai": "^4.3.10", + "eslint": "^8.56.0", + "eslint-config-prettier": "^9.1.0", + "eslint-plugin-mocha": "^10.2.0", + "eslint-plugin-prettier": "^5.0.1", + "glob-expand": "^0.2.1", + "mocha": "^10.2.0", + "prettier": "^3.1.1", + "rimraf": "^5.0.5", + "write": "^2.0.0" + }, + "dependencies": { + "flat-cache": "^4.0.0" + } +} diff --git a/tools/ui/node_modules/filelist/README.md b/tools/ui/node_modules/filelist/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b52ebe7c5a7069864565b774426d021ec65e5fe2 --- /dev/null +++ b/tools/ui/node_modules/filelist/README.md @@ -0,0 +1,84 @@ +## FileList + +A FileList is a lazy-evaluated list of files. When given a list +of glob patterns for possible files to be included in the file +list, instead of searching the file structures to find the files, +a FileList holds the pattern for latter use. + +This allows you to define a FileList to match any number of +files, but only search out the actual files when then FileList +itself is actually used. The key is that the first time an +element of the FileList/Array is requested, the pending patterns +are resolved into a real list of file names. + +### Usage + +Add files to the list with the `include` method. You can add glob +patterns, individual files, or RegExp objects. When the Array +methods are invoked on the FileList, these items are resolved to +an actual list of files. + +```javascript +var fl = new FileList(); +fl.include('test/*.js'); +fl.exclude('test/helpers.js'); +``` + +Use the `exclude` method to override inclusions. You can use this +when your inclusions are too broad. + +### Array methods + +FileList has lazy-evaluated versions of most of the array +methods, including the following: + +* join +* pop +* push +* concat +* reverse +* shift +* unshift +* slice +* splice +* sort +* filter +* forEach +* some +* every +* map +* indexOf +* lastIndexOf +* reduce +* reduceRight + +When you call one of these methods, the items in the FileList +will be resolved to the full list of files, and the method will +be invoked on that result. + +### Special `length` method + +`length`: FileList includes a length *method* (instead of a +property) which returns the number of actual files in the list +once it's been resolved. + +### FileList-specific methods + +`include`: Add a filename/glob/regex to the list + +`exclude`: Override inclusions by excluding a filename/glob/regex + +`resolve`: Resolve the items in the FileList to the full list of +files. This method is invoked automatically when one of the array +methods is called. + +`toArray`: Immediately resolves the list of items, and returns an +actual array of filepaths. + +`clearInclusions`: Clears any pending items -- must be used +before resolving the list. + +`clearExclusions`: Clears the list of exclusions rules. + + + diff --git a/tools/ui/node_modules/filelist/index.d.ts b/tools/ui/node_modules/filelist/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a6addf28ca0b05e613a4ee0c34adf4131ed3b46b --- /dev/null +++ b/tools/ui/node_modules/filelist/index.d.ts @@ -0,0 +1,110 @@ +// IncludeOptions definitions copied from minimatch (https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/minimatch/index.d.ts) +interface IncludeOptions { + /** + * Dump a ton of stuff to stderr. + * + * @default false + */ + debug?: boolean; + + /** + * Do not expand {a,b} and {1..3} brace sets. + * + * @default false + */ + nobrace?: boolean; + + /** + * Disable ** matching against multiple folder names. + * + * @default false + */ + noglobstar?: boolean; + + /** + * Allow patterns to match filenames starting with a period, + * even if the pattern does not explicitly have a period in that spot. + * + * @default false + */ + dot?: boolean; + + /** + * Disable "extglob" style patterns like +(a|b). + * + * @default false + */ + noext?: boolean; + + /** + * Perform a case-insensitive match. + * + * @default false + */ + nocase?: boolean; + + /** + * When a match is not found by minimatch.match, + * return a list containing the pattern itself if this option is set. + * Otherwise, an empty list is returned if there are no matches. + * + * @default false + */ + nonull?: boolean; + + /** + * If set, then patterns without slashes will be matched against + * the basename of the path if it contains slashes. + * + * @default false + */ + matchBase?: boolean; + + /** + * Suppress the behavior of treating # + * at the start of a pattern as a comment. + * + * @default false + */ + nocomment?: boolean; + + /** + * Suppress the behavior of treating a leading ! character as negation. + * + * @default false + */ + nonegate?: boolean; + + /** + * Returns from negate expressions the same as if they were not negated. + * (Ie, true on a hit, false on a miss.) + * + * @default false + */ + flipNegate?: boolean; +} + +export class FileList { + static clone(): FileList + static verbose: boolean +} + +export interface FileList extends Omit, "length"> { + pendingAdd: string[] + pending: boolean + excludes: { + pats: RegExp[], + funcs: Function[], + regex: null | RegExp + } + items: string[] + toArray(): string[] + include(...items: string[]): this + include(...items: (IncludeOptions | string)[]): this + exclude(...items: string[]): this + shouldExclude(item: string): boolean + resolve(): this + clearInclusions(): this + clearExclusions(): this + length(): number +} \ No newline at end of file diff --git a/tools/ui/node_modules/filelist/index.js b/tools/ui/node_modules/filelist/index.js new file mode 100644 index 0000000000000000000000000000000000000000..34ca389745f6b1548d2f4a8102aa6bf0fc843eab --- /dev/null +++ b/tools/ui/node_modules/filelist/index.js @@ -0,0 +1,495 @@ +/* + * Jake JavaScript build tool + * Copyright 2112 Matthew Eernisse (mde@fleegix.org) + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * +*/ +var fs = require('fs') +, path = require('path') +, minimatch = require('minimatch') +, escapeRegExpChars +, merge +, basedir +, _readDir +, readdirR +, globSync; +var hasOwnProperty = Object.prototype.hasOwnProperty; +var hasOwn = function (obj, key) { return hasOwnProperty.apply(obj, [key]); }; + + /** + @name escapeRegExpChars + @function + @return {String} A string of escaped characters + @description Escapes regex control-characters in strings + used to build regexes dynamically + @param {String} string The string of chars to escape + */ + escapeRegExpChars = (function () { + var specials = [ '^', '$', '/', '.', '*', '+', '?', '|', '(', ')', + '[', ']', '{', '}', '\\' ]; + var sRE = new RegExp('(\\' + specials.join('|\\') + ')', 'g'); + return function (string) { + var str = string || ''; + str = String(str); + return str.replace(sRE, '\\$1'); + }; + })(); + + /** + @name merge + @function + @return {Object} Returns the merged object + @description Merge merges `otherObject` into `object` and takes care of deep + merging of objects + @param {Object} object Object to merge into + @param {Object} otherObject Object to read from + */ + merge = function (object, otherObject) { + var obj = object || {} + , otherObj = otherObject || {} + , key, value; + + for (key in otherObj) { + + if (!hasOwn(otherObj, key)) { + continue; + } + if (key === '__proto__' || key === 'constructor') { + continue; + } + + value = otherObj[key]; + // Check if a value is an Object, if so recursively add it's key/values + if (typeof value === 'object' && !(value instanceof Array)) { + // Update value of object to the one from otherObj + obj[key] = merge(obj[key], value); + } + // Value is anything other than an Object, so just add it + else { + obj[key] = value; + } + } + + return obj; + }; + /** + Given a patern, return the base directory of it (ie. the folder + that will contain all the files matching the path). + eg. file.basedir('/test/**') => '/test/' + Path ending by '/' are considerd as folder while other are considerd + as files, eg.: + file.basedir('/test/a/') => '/test/a' + file.basedir('/test/a') => '/test' + The returned path always end with a '/' so we have: + file.basedir(file.basedir(x)) == file.basedir(x) + */ + basedir = function (pathParam) { + var bd = '' + , parts + , part + , pos = 0 + , p = pathParam || ''; + + // If the path has a leading asterisk, basedir is the current dir + if (p.indexOf('*') == 0 || p.indexOf('**') == 0) { + return '.'; + } + + // always consider .. at the end as a folder and not a filename + if (/(?:^|\/|\\)\.\.$/.test(p.slice(-3))) { + p += '/'; + } + + parts = p.split(/\\|\//); + for (var i = 0, l = parts.length - 1; i < l; i++) { + part = parts[i]; + if (part.indexOf('*') > -1 || part.indexOf('**') > -1) { + break; + } + pos += part.length + 1; + bd += part + p[pos - 1]; + } + if (!bd) { + bd = '.'; + } + // Strip trailing slashes + if (!(bd == '\\' || bd == '/')) { + bd = bd.replace(/\\$|\/$/, ''); + } + return bd; + + }; + + // Return the contents of a given directory + _readDir = function (dirPath) { + var dir = path.normalize(dirPath) + , paths = [] + , ret = [dir] + , msg; + + try { + paths = fs.readdirSync(dir); + } + catch (e) { + msg = 'Could not read path ' + dir + '\n'; + if (e.stack) { + msg += e.stack; + } + throw new Error(msg); + } + + paths.forEach(function (p) { + var curr = path.join(dir, p); + var stat = fs.statSync(curr); + if (stat.isDirectory()) { + ret = ret.concat(_readDir(curr)); + } + else { + ret.push(curr); + } + }); + + return ret; + }; + + /** + @name file#readdirR + @function + @return {Array} Returns the contents as an Array, can be configured via opts.format + @description Reads the given directory returning it's contents + @param {String} dir The directory to read + @param {Object} opts Options to use + @param {String} [opts.format] Set the format to return(Default: Array) + */ + readdirR = function (dir, opts) { + var options = opts || {} + , format = options.format || 'array' + , ret; + ret = _readDir(dir); + return format == 'string' ? ret.join('\n') : ret; + }; + + +globSync = function (pat, opts) { + var dirname = basedir(pat) + , files + , matches; + + try { + files = readdirR(dirname).map(function(file){ + return file.replace(/\\/g, '/'); + }); + } + // Bail if path doesn't exist -- assume no files + catch(e) { + if (FileList.verbose) console.error(e.message); + } + + if (files) { + pat = path.normalize(pat); + matches = minimatch.match(files, pat, opts || {}); + } + return matches || []; +}; + +// Constants +// --------------- +// List of all the builtin Array methods we want to override +var ARRAY_METHODS = Object.getOwnPropertyNames(Array.prototype) +// Array methods that return a copy instead of affecting the original + , SPECIAL_RETURN = { + 'concat': true + , 'slice': true + , 'filter': true + , 'map': true + } +// Default file-patterns we want to ignore + , DEFAULT_IGNORE_PATTERNS = [ + /(^|[\/\\])CVS([\/\\]|$)/ + , /(^|[\/\\])\.svn([\/\\]|$)/ + , /(^|[\/\\])\.git([\/\\]|$)/ + , /\.bak$/ + , /~$/ + ] +// Ignore core files + , DEFAULT_IGNORE_FUNCS = [ + function (name) { + var isDir = false + , stats; + try { + stats = fs.statSync(name); + isDir = stats.isDirectory(); + } + catch(e) {} + return (/(^|[\/\\])core$/).test(name) && !isDir; + } + ]; + +var FileList = function () { + var self = this + , wrap; + + // List of glob-patterns or specific filenames + this.pendingAdd = []; + // Switched to false after lazy-eval of files + this.pending = true; + // Used to calculate exclusions from the list of files + this.excludes = { + pats: DEFAULT_IGNORE_PATTERNS.slice() + , funcs: DEFAULT_IGNORE_FUNCS.slice() + , regex: null + }; + this.items = []; + + // Wrap the array methods with the delegates + wrap = function (prop) { + var arr; + self[prop] = function () { + if (self.pending) { + self.resolve(); + } + if (typeof self.items[prop] == 'function') { + // Special method that return a copy + if (SPECIAL_RETURN[prop]) { + arr = self.items[prop].apply(self.items, arguments); + return FileList.clone(self, arr); + } + else { + return self.items[prop].apply(self.items, arguments); + } + } + else { + return self.items[prop]; + } + }; + }; + for (var i = 0, ii = ARRAY_METHODS.length; i < ii; i++) { + wrap(ARRAY_METHODS[i]); + } + + // Include whatever files got passed to the constructor + this.include.apply(this, arguments); + + // Fix constructor linkage + this.constructor = FileList; +}; + +FileList.prototype = new (function () { + var globPattern = /[*?\[\{]/; + + var _addMatching = function (item) { + var matches = globSync(item.path, item.options); + this.items = this.items.concat(matches); + } + + , _resolveAdd = function (item) { + if (globPattern.test(item.path)) { + _addMatching.call(this, item); + } + else { + this.push(item.path); + } + } + + , _calculateExcludeRe = function () { + var pats = this.excludes.pats + , pat + , excl = [] + , matches = []; + + for (var i = 0, ii = pats.length; i < ii; i++) { + pat = pats[i]; + if (typeof pat == 'string') { + // Glob, look up files + if (/[*?]/.test(pat)) { + matches = globSync(pat); + matches = matches.map(function (m) { + return escapeRegExpChars(m); + }); + excl = excl.concat(matches); + } + // String for regex + else { + excl.push(escapeRegExpChars(pat)); + } + } + // Regex, grab the string-representation + else if (pat instanceof RegExp) { + excl.push(pat.toString().replace(/^\/|\/$/g, '')); + } + } + if (excl.length) { + this.excludes.regex = new RegExp('(' + excl.join(')|(') + ')'); + } + else { + this.excludes.regex = /^$/; + } + } + + , _resolveExclude = function () { + var self = this; + _calculateExcludeRe.call(this); + // No `reject` method, so use reverse-filter + this.items = this.items.filter(function (name) { + return !self.shouldExclude(name); + }); + }; + + /** + * Includes file-patterns in the FileList. Should be called with one or more + * pattern for finding file to include in the list. Arguments should be strings + * for either a glob-pattern or a specific file-name, or an array of them + */ + this.include = function () { + var args = Array.prototype.slice.call(arguments) + , arg + , includes = { items: [], options: {} }; + + for (var i = 0, ilen = args.length; i < ilen; i++) { + arg = args[i]; + + if (typeof arg === 'object' && !Array.isArray(arg)) { + merge(includes.options, arg); + } else { + includes.items = includes.items.concat(arg).filter(function (item) { + return !!item; + }); + } + } + + var items = includes.items.map(function(item) { + return { path: item, options: includes.options }; + }); + + this.pendingAdd = this.pendingAdd.concat(items); + + return this; + }; + + /** + * Indicates whether a particular file would be filtered out by the current + * exclusion rules for this FileList. + * @param {String} name The filename to check + * @return {Boolean} Whether or not the file should be excluded + */ + this.shouldExclude = function (name) { + if (!this.excludes.regex) { + _calculateExcludeRe.call(this); + } + var excl = this.excludes; + return excl.regex.test(name) || excl.funcs.some(function (f) { + return !!f(name); + }); + }; + + /** + * Excludes file-patterns from the FileList. Should be called with one or more + * pattern for finding file to include in the list. Arguments can be: + * 1. Strings for either a glob-pattern or a specific file-name + * 2. Regular expression literals + * 3. Functions to be run on the filename that return a true/false + */ + this.exclude = function () { + var args = Array.isArray(arguments[0]) ? arguments[0] : arguments + , arg; + for (var i = 0, ii = args.length; i < ii; i++) { + arg = args[i]; + if (typeof arg == 'function' && !(arg instanceof RegExp)) { + this.excludes.funcs.push(arg); + } + else { + this.excludes.pats.push(arg); + } + } + if (!this.pending) { + _resolveExclude.call(this); + } + return this; + }; + + /** + * Populates the FileList from the include/exclude rules with a list of + * actual files + */ + this.resolve = function () { + var item + , uniqueFunc = function (p, c) { + if (p.indexOf(c) < 0) { + p.push(c); + } + return p; + }; + if (this.pending) { + this.pending = false; + while ((item = this.pendingAdd.shift())) { + _resolveAdd.call(this, item); + } + // Reduce to a unique list + this.items = this.items.reduce(uniqueFunc, []); + // Remove exclusions + _resolveExclude.call(this); + } + return this; + }; + + /** + * Convert to a plain-jane array + */ + this.toArray = function () { + // Call slice to ensure lazy-resolution before slicing items + var ret = this.slice().items.slice(); + return ret; + }; + + /** + * Clear any pending items -- only useful before + * calling `resolve` + */ + this.clearInclusions = function () { + this.pendingAdd = []; + return this; + }; + + /** + * Clear any current exclusion rules + */ + this.clearExclusions = function () { + this.excludes = { + pats: [] + , funcs: [] + , regex: null + }; + return this; + }; + +})(); + +// Static method, used to create copy returned by special +// array methods +FileList.clone = function (list, items) { + var clone = new FileList(); + if (items) { + clone.items = items; + } + clone.pendingAdd = list.pendingAdd; + clone.pending = list.pending; + for (var p in list.excludes) { + clone.excludes[p] = list.excludes[p]; + } + return clone; +}; + +FileList.verbose = true + +exports.FileList = FileList; diff --git a/tools/ui/node_modules/filelist/jakefile.js b/tools/ui/node_modules/filelist/jakefile.js new file mode 100644 index 0000000000000000000000000000000000000000..18d4d7df09a3cdf3d4c428331369a1f274025053 --- /dev/null +++ b/tools/ui/node_modules/filelist/jakefile.js @@ -0,0 +1,15 @@ +testTask('FileList', function () { + this.testFiles.include('test/*.js'); +}); + +publishTask('FileList', function () { + this.packageFiles.include([ + 'jakefile.js', + 'README.md', + 'package.json', + 'index.js', + 'index.d.ts' + ]); +}); + + diff --git a/tools/ui/node_modules/filelist/node_modules/brace-expansion/.github/FUNDING.yml b/tools/ui/node_modules/filelist/node_modules/brace-expansion/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..79d1eafceccdfd94e9da95af5ccc8ccce24f198b --- /dev/null +++ b/tools/ui/node_modules/filelist/node_modules/brace-expansion/.github/FUNDING.yml @@ -0,0 +1,2 @@ +tidelift: "npm/brace-expansion" +patreon: juliangruber diff --git a/tools/ui/node_modules/filelist/node_modules/brace-expansion/LICENSE b/tools/ui/node_modules/filelist/node_modules/brace-expansion/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..de3226673c3874b1c6506db022393c753495655c --- /dev/null +++ b/tools/ui/node_modules/filelist/node_modules/brace-expansion/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2013 Julian Gruber + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/filelist/node_modules/brace-expansion/README.md b/tools/ui/node_modules/filelist/node_modules/brace-expansion/README.md new file mode 100644 index 0000000000000000000000000000000000000000..bda4ed36004d45218f9952d50bec1951ff0369fa --- /dev/null +++ b/tools/ui/node_modules/filelist/node_modules/brace-expansion/README.md @@ -0,0 +1,157 @@ +# brace-expansion + +[Brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html), +as known from sh/bash, in JavaScript. + +[![build status](https://secure.travis-ci.org/juliangruber/brace-expansion.svg)](http://travis-ci.org/juliangruber/brace-expansion) +[![downloads](https://img.shields.io/npm/dm/brace-expansion.svg)](https://www.npmjs.org/package/brace-expansion) +[![Greenkeeper badge](https://badges.greenkeeper.io/juliangruber/brace-expansion.svg)](https://greenkeeper.io/) + +[![testling badge](https://ci.testling.com/juliangruber/brace-expansion.png)](https://ci.testling.com/juliangruber/brace-expansion) + +## Example + +```js +var expand = require('brace-expansion'); + +expand('file-{a,b,c}.jpg') +// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg'] + +expand('-v{,,}') +// => ['-v', '-v', '-v'] + +expand('file{0..2}.jpg') +// => ['file0.jpg', 'file1.jpg', 'file2.jpg'] + +expand('file-{a..c}.jpg') +// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg'] + +expand('file{2..0}.jpg') +// => ['file2.jpg', 'file1.jpg', 'file0.jpg'] + +expand('file{0..4..2}.jpg') +// => ['file0.jpg', 'file2.jpg', 'file4.jpg'] + +expand('file-{a..e..2}.jpg') +// => ['file-a.jpg', 'file-c.jpg', 'file-e.jpg'] + +expand('file{00..10..5}.jpg') +// => ['file00.jpg', 'file05.jpg', 'file10.jpg'] + +expand('{{A..C},{a..c}}') +// => ['A', 'B', 'C', 'a', 'b', 'c'] + +expand('ppp{,config,oe{,conf}}') +// => ['ppp', 'pppconfig', 'pppoe', 'pppoeconf'] +``` + +## API + +```js +var expand = require('brace-expansion'); +``` + +### var expanded = expand(str, [options]) + +Return an array of all possible and valid expansions of `str`. If none are +found, `[str]` is returned. + +The `options` object can provide a `max` value to cap the number +of expansions allowed. This is limited to `100_000` by default, +to prevent DoS attacks. + +```js +const expansions = expand('{1..100}'.repeat(5), { + max: 100, +}) +// expansions.length will be 100, not 100^5 +``` + +The `options` object can also provide a `maxLength` value to cap the +total number of characters across all expansions. This is limited to +`4_000_000` by default, to prevent memory exhaustion from inputs whose +result count stays under `max` while each result grows very long. + +```js +const expansions = expand('{a,b}'.repeat(1500), { + maxLength: 10_000, +}) +``` + +Valid expansions are: + +```js +/^(.*,)+(.+)?$/ +// {a,b,...} +``` + +A comma separated list of options, like `{a,b}` or `{a,{b,c}}` or `{,a,}`. + +```js +/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/ +// {x..y[..incr]} +``` + +A numeric sequence from `x` to `y` inclusive, with optional increment. +If `x` or `y` start with a leading `0`, all the numbers will be padded +to have equal length. Negative numbers and backwards iteration work too. + +```js +/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/ +// {x..y[..incr]} +``` + +An alphabetic sequence from `x` to `y` inclusive, with optional increment. +`x` and `y` must be exactly one character, and if given, `incr` must be a +number. + +For compatibility reasons, the string `${` is not eligible for brace expansion. + +## Installation + +With [npm](https://npmjs.org) do: + +```bash +npm install brace-expansion +``` + +## Contributors + +- [Julian Gruber](https://github.com/juliangruber) +- [Isaac Z. Schlueter](https://github.com/isaacs) + +## Sponsors + +This module is proudly supported by my [Sponsors](https://github.com/juliangruber/sponsors)! + +Do you want to support modules like this to improve their quality, stability and weigh in on new features? Then please consider donating to my [Patreon](https://www.patreon.com/juliangruber). Not sure how much of my modules you're using? Try [feross/thanks](https://github.com/feross/thanks)! + +## Security contact information + +To report a security vulnerability, please use the +[Tidelift security contact](https://tidelift.com/security). +Tidelift will coordinate the fix and disclosure. + +## License + +(MIT) + +Copyright (c) 2013 Julian Gruber <julian@juliangruber.com> + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/filelist/node_modules/brace-expansion/index.js b/tools/ui/node_modules/filelist/node_modules/brace-expansion/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ee07f02bf825602973d86de59ff0c03404a0ce25 --- /dev/null +++ b/tools/ui/node_modules/filelist/node_modules/brace-expansion/index.js @@ -0,0 +1,338 @@ +var balanced = require('balanced-match'); + +module.exports = expandTop; + +var escSlash = '\0SLASH'+Math.random()+'\0'; +var escOpen = '\0OPEN'+Math.random()+'\0'; +var escClose = '\0CLOSE'+Math.random()+'\0'; +var escComma = '\0COMMA'+Math.random()+'\0'; +var escPeriod = '\0PERIOD'+Math.random()+'\0'; + +var EXPANSION_MAX = 100000 + +// `EXPANSION_MAX` caps the *number* of expansions, but not their length. An +// input like `'{a,b}'.repeat(1500)` stays under that count - its output is +// truncated to 100k results - while making every result ~1500 characters +// long. The result set, and the intermediate arrays built while combining +// brace sets, then grow large enough to exhaust memory and crash the process +// (CVE-2026-14257). `EXPANSION_MAX_LENGTH` bounds the total number of +// characters the accumulator may hold at any point, so memory stays flat no +// matter how many brace groups are chained. The limit sits well above any +// realistic expansion (100k results hitting `EXPANSION_MAX` measure ~1M +// characters) so legitimate input is unaffected. +var EXPANSION_MAX_LENGTH = 4000000 + +function numeric(str) { + return parseInt(str, 10) == str + ? parseInt(str, 10) + : str.charCodeAt(0); +} + +function escapeBraces(str) { + return str.split('\\\\').join(escSlash) + .split('\\{').join(escOpen) + .split('\\}').join(escClose) + .split('\\,').join(escComma) + .split('\\.').join(escPeriod); +} + +function unescapeBraces(str) { + return str.split(escSlash).join('\\') + .split(escOpen).join('{') + .split(escClose).join('}') + .split(escComma).join(',') + .split(escPeriod).join('.'); +} + + +// Basically just str.split(","), but handling cases +// where we have nested braced sections, which should be +// treated as individual members, like {a,{b,c},d} +function parseCommaParts(str) { + if (!str) + return ['']; + + var parts = []; + var m = balanced('{', '}', str); + + if (!m) + return str.split(','); + + var pre = m.pre; + var body = m.body; + var post = m.post; + var p = pre.split(','); + + p[p.length-1] += '{' + body + '}'; + var postParts = parseCommaParts(post); + if (post.length) { + p[p.length-1] += postParts.shift(); + p.push.apply(p, postParts); + } + + parts.push.apply(parts, p); + + return parts; +} + +function expandTop(str, options) { + if (!str) + return []; + + options = options || {}; + var max = options.max == null ? EXPANSION_MAX : options.max; + var maxLength = options.maxLength == null ? EXPANSION_MAX_LENGTH : options.maxLength; + + // I don't know why Bash 4.3 does this, but it does. + // Anything starting with {} will have the first two bytes preserved + // but *only* at the top level, so {},a}b will not expand to anything, + // but a{},b}c will be expanded to [a}c,abc]. + // One could argue that this is a bug in Bash, but since the goal of + // this module is to match Bash's rules, we escape a leading {} + if (str.substr(0, 2) === '{}') { + str = '\\{\\}' + str.substr(2); + } + + return expand(escapeBraces(str), max, maxLength, true).map(unescapeBraces); +} + +function embrace(str) { + return '{' + str + '}'; +} +function isPadded(el) { + return /^-?0\d/.test(el); +} + +function lte(i, y) { + return i <= y; +} +function gte(i, y) { + return i >= y; +} + +// Build `{ acc[a] + pre + values[v] }` for every combination, capping the +// number of results at `max` and the total number of characters at `maxLength`. +// This is the one place output grows, so bounding it here keeps the single +// accumulator - and therefore memory - flat regardless of how many brace groups +// are combined (CVE-2026-14257). +function combine( + acc, + pre, + values, + max, + maxLength, + dropEmpties +) { + var out = [] + var length = 0 + for (var a = 0; a < acc.length; a++) { + for (var v = 0; v < values.length; v++) { + if (out.length >= max) return out + var expansion = acc[a] + pre + values[v] + // Bash drops empty results at the top level. Skip them before they count + // against `max`, so `max` bounds the number of *kept* results. + if (dropEmpties && !expansion) continue + if (length + expansion.length > maxLength) return out + out.push(expansion) + length += expansion.length + } + } + return out +} + +// The expansion values of a single numeric (`1..5`) or alphabetic (`a..e..2`) +// sequence body. +function expandSequence( + body, + isAlphaSequence, + max, + maxLength +) { + var n = body.split(/\.\./) + var N = [] + // A sequence body always splits into two or three parts, but the compiler + // can't know that. + /* c8 ignore start */ + if (n[0] === undefined || n[1] === undefined) { + return N + } + /* c8 ignore stop */ + var x = numeric(n[0]) + var y = numeric(n[1]) + var width = Math.max(n[0].length, n[1].length) + var incr = + n.length === 3 && n[2] !== undefined ? + Math.max(Math.abs(numeric(n[2])), 1) + : 1 + var test = lte + var reverse = y < x + if (reverse) { + incr *= -1 + test = gte + } + var pad = n.some(isPadded) + + var length = 0 + for (var i = x; test(i, y) && N.length < max; i += incr) { + var c + if (isAlphaSequence) { + c = String.fromCharCode(i) + if (c === '\\') { + c = '' + } + } else { + c = String(i) + if (pad) { + var need = width - c.length + if (need > 0) { + var z = new Array(need + 1).join('0') + if (i < 0) { + c = '-' + z + c.slice(1) + } else { + c = z + c + } + } + } + } + if (length + c.length > maxLength) break + N.push(c) + length += c.length + } + return N +} + +function expand( + str, + max, + maxLength, + isTop +) { + // Consume the string's top-level brace groups left to right, threading a + // running set of combined prefixes (`acc`). Expanding the tail iteratively - + // rather than recursing on `m.post` once per group - keeps the native stack + // depth constant, so deeply chained input (`'{a,b}'.repeat(3000)`) can no + // longer overflow the stack, and leaves a single accumulator whose size + // `maxLength` bounds directly (CVE-2026-14257). + var acc = [''] + + // Bash drops empty results, but only when the *first* top-level group is a + // comma set - a sequence like `{a..\}` may legitimately yield ''. The drop + // is on the final strings, so it is applied to whichever `combine` produces + // them (the one with no brace set left in the tail). + var dropEmpties = false + var firstGroup = true + + for (;;) { + const m = balanced('{', '}', str) + + // No brace set left: the rest of the string is literal. + if (!m) { + return combine(acc, str, [''], max, maxLength, dropEmpties) + } + + // no need to expand pre, since it is guaranteed to be free of brace-sets + const pre = m.pre + + if (/\$$/.test(pre)) { + acc = combine( + acc, + pre + '{' + m.body + '}', + [''], + max, + maxLength, + dropEmpties && !m.post.length + ) + firstGroup = false + if (!m.post.length) break + str = m.post + continue + } + + var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body); + var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body); + var isSequence = isNumericSequence || isAlphaSequence; + var isOptions = m.body.indexOf(',') >= 0; + if (!isSequence && !isOptions) { + // {a},b} + if (m.post.match(/,(?!,).*\}/)) { + str = m.pre + '{' + m.body + escClose + m.post; + isTop = true; + continue; + } + // Nothing here expands, so the whole remaining string is literal. + return combine( + acc, + pre + '{' + m.body + '}' + m.post, + [''], + max, + maxLength, + dropEmpties + ) + } + + if (firstGroup) { + dropEmpties = isTop && !isSequence + firstGroup = false + } + + var values; + if (isSequence) { + values = expandSequence(m.body, isAlphaSequence, max, maxLength); + } else { + var n = parseCommaParts(m.body); + if (n.length === 1 && n[0] !== undefined) { + // x{{a,b}}y ==> x{a}y x{b}y + n = expand(n[0], max, maxLength, false).map(embrace); + //XXX is this necessary? Can't seem to hit it in tests. + /* c8 ignore start */ + if (n.length === 1) { + acc = combine( + acc, + pre + n[0], + [''], + max, + maxLength, + dropEmpties && !m.post.length + ) + if (!m.post.length) break + str = m.post + continue + } + /* c8 ignore stop */ + } + + // Values that `combine` is going to drop as empty produce no result, so + // they must not count against `max` - otherwise `{a,,b}` with `max: 2` + // would stop at `['a', '']` and yield one result instead of two. Skipping + // them outright keeps `values` bounded while leaving `max` a bound on + // *kept* results. + var dropsEmpties = dropEmpties && !m.post.length && !pre + for (var d = 0; dropsEmpties && d < acc.length; d++) { + if (acc[d]) { + dropsEmpties = false + } + } + + values = [] + var valuesLength = 0 + outer: for (var j = 0; j < n.length; j++) { + var expanded = expand(n[j], max, maxLength, false) + for (var k = 0; k < expanded.length; k++) { + var v = expanded[k] + if (dropsEmpties && !v) continue + if (values.length >= max || valuesLength + v.length > maxLength) { + break outer + } + values.push(v) + valuesLength += v.length + } + } + } + + acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length) + if (!m.post.length) break + str = m.post + } + + return acc +} diff --git a/tools/ui/node_modules/filelist/node_modules/brace-expansion/package.json b/tools/ui/node_modules/filelist/node_modules/brace-expansion/package.json new file mode 100644 index 0000000000000000000000000000000000000000..787925f0ab8ddfb56af7f41100719aab22eafc76 --- /dev/null +++ b/tools/ui/node_modules/filelist/node_modules/brace-expansion/package.json @@ -0,0 +1,49 @@ +{ + "name": "brace-expansion", + "description": "Brace expansion as known from sh/bash", + "version": "2.1.4", + "repository": { + "type": "git", + "url": "git://github.com/juliangruber/brace-expansion.git" + }, + "homepage": "https://github.com/juliangruber/brace-expansion", + "main": "index.js", + "scripts": { + "test": "tape test/*.js", + "gentest": "bash test/generate.sh", + "bench": "matcha test/perf/bench.js" + }, + "dependencies": { + "balanced-match": "^1.0.0" + }, + "devDependencies": { + "@c4312/matcha": "^1.3.1", + "tape": "^4.6.0" + }, + "keywords": [], + "author": { + "name": "Julian Gruber", + "email": "mail@juliangruber.com", + "url": "http://juliangruber.com" + }, + "license": "MIT", + "testling": { + "files": "test/*.js", + "browsers": [ + "ie/8..latest", + "firefox/20..latest", + "firefox/nightly", + "chrome/25..latest", + "chrome/canary", + "opera/12..latest", + "opera/next", + "safari/5.1..latest", + "ipad/6.0..latest", + "iphone/6.0..latest", + "android-browser/4.2..latest" + ] + }, + "publishConfig": { + "tag": "2.x" + } +} diff --git a/tools/ui/node_modules/filelist/node_modules/minimatch/LICENSE b/tools/ui/node_modules/filelist/node_modules/minimatch/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1493534e60dce4a4c73e60e0bb448a0ab2567c9d --- /dev/null +++ b/tools/ui/node_modules/filelist/node_modules/minimatch/LICENSE @@ -0,0 +1,15 @@ +The ISC License + +Copyright (c) 2011-2023 Isaac Z. Schlueter and Contributors + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/tools/ui/node_modules/filelist/node_modules/minimatch/README.md b/tools/ui/node_modules/filelist/node_modules/minimatch/README.md new file mode 100644 index 0000000000000000000000000000000000000000..761a00460de6fe5c6713bdc7db66e3d00844f9e7 --- /dev/null +++ b/tools/ui/node_modules/filelist/node_modules/minimatch/README.md @@ -0,0 +1,296 @@ +# minimatch + +A minimal matching utility. + +[![Build Status](https://travis-ci.org/isaacs/minimatch.svg?branch=master)](http://travis-ci.org/isaacs/minimatch) + + +This is the matching library used internally by npm. + +It works by converting glob expressions into JavaScript `RegExp` +objects. + +## Important Security Consideration! + +> [!WARNING] +> This library uses JavaScript regular expressions. Please read +> the following warning carefully, and be thoughtful about what +> you provide to this library in production systems. + +_Any_ library in JavaScript that deals with matching string +patterns using regular expressions will be subject to +[ReDoS](https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS) +if the pattern is generated using untrusted input. + +Efforts have been made to mitigate risk as much as is feasible in +such a library, providing maximum recursion depths and so forth, +but these measures can only ultimately protect against accidents, +not malice. A dedicated attacker can _always_ find patterns that +cannot be defended against by a bash-compatible glob pattern +matching system that uses JavaScript regular expressions. + +To be extremely clear: + +> [!WARNING] +> **If you create a system where you take user input, and use +> that input as the source of a Regular Expression pattern, in +> this or any extant glob matcher in JavaScript, you will be +> pwned.** + +A future version of this library _may_ use a different matching +algorithm which does not exhibit backtracking problems. If and +when that happens, it will likely be a sweeping change, and those +improvements will **not** be backported to legacy versions. + +In the near term, it is not reasonable to continue to play +whack-a-mole with security advisories, and so any future ReDoS +reports will be considered "working as intended", and resolved +entirely by this warning. + +## Usage + +```javascript +var minimatch = require("minimatch") + +minimatch("bar.foo", "*.foo") // true! +minimatch("bar.foo", "*.bar") // false! +minimatch("bar.foo", "*.+(bar|foo)", { debug: true }) // true, and noisy! +``` + +## Features + +Supports these glob features: + +* Brace Expansion +* Extended glob matching +* "Globstar" `**` matching + +See: + +* `man sh` +* `man bash` +* `man 3 fnmatch` +* `man 5 gitignore` + +## Windows + +**Please only use forward-slashes in glob expressions.** + +Though windows uses either `/` or `\` as its path separator, only `/` +characters are used by this glob implementation. You must use +forward-slashes **only** in glob expressions. Back-slashes in patterns +will always be interpreted as escape characters, not path separators. + +Note that `\` or `/` _will_ be interpreted as path separators in paths on +Windows, and will match against `/` in glob expressions. + +So just always use `/` in patterns. + +## Minimatch Class + +Create a minimatch object by instantiating the `minimatch.Minimatch` class. + +```javascript +var Minimatch = require("minimatch").Minimatch +var mm = new Minimatch(pattern, options) +``` + +### Properties + +* `pattern` The original pattern the minimatch object represents. +* `options` The options supplied to the constructor. +* `set` A 2-dimensional array of regexp or string expressions. + Each row in the + array corresponds to a brace-expanded pattern. Each item in the row + corresponds to a single path-part. For example, the pattern + `{a,b/c}/d` would expand to a set of patterns like: + + [ [ a, d ] + , [ b, c, d ] ] + + If a portion of the pattern doesn't have any "magic" in it + (that is, it's something like `"foo"` rather than `fo*o?`), then it + will be left as a string rather than converted to a regular + expression. + +* `regexp` Created by the `makeRe` method. A single regular expression + expressing the entire pattern. This is useful in cases where you wish + to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled. +* `negate` True if the pattern is negated. +* `comment` True if the pattern is a comment. +* `empty` True if the pattern is `""`. + +### Methods + +* `makeRe` Generate the `regexp` member if necessary, and return it. + Will return `false` if the pattern is invalid. +* `match(fname)` Return true if the filename matches the pattern, or + false otherwise. +* `matchOne(fileArray, patternArray, partial)` Take a `/`-split + filename, and match it against a single row in the `regExpSet`. This + method is mainly for internal use, but is exposed so that it can be + used by a glob-walker that needs to avoid excessive filesystem calls. + +All other methods are internal, and will be called as necessary. + +### minimatch(path, pattern, options) + +Main export. Tests a path against the pattern using the options. + +```javascript +var isJS = minimatch(file, "*.js", { matchBase: true }) +``` + +### minimatch.filter(pattern, options) + +Returns a function that tests its +supplied argument, suitable for use with `Array.filter`. Example: + +```javascript +var javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true})) +``` + +### minimatch.match(list, pattern, options) + +Match against the list of +files, in the style of fnmatch or glob. If nothing is matched, and +options.nonull is set, then return a list containing the pattern itself. + +```javascript +var javascripts = minimatch.match(fileList, "*.js", {matchBase: true}) +``` + +### minimatch.makeRe(pattern, options) + +Make a regular expression object from the pattern. + +## Options + +All options are `false` by default. + +### debug + +Dump a ton of stuff to stderr. + +### nobrace + +Do not expand `{a,b}` and `{1..3}` brace sets. + +### noglobstar + +Disable `**` matching against multiple folder names. + +### dot + +Allow patterns to match filenames starting with a period, even if +the pattern does not explicitly have a period in that spot. + +Note that by default, `a/**/b` will **not** match `a/.d/b`, unless `dot` +is set. + +### noext + +Disable "extglob" style patterns like `+(a|b)`. + +### nocase + +Perform a case-insensitive match. + +### nonull + +When a match is not found by `minimatch.match`, return a list containing +the pattern itself if this option is set. When not set, an empty list +is returned if there are no matches. + +### matchBase + +If set, then patterns without slashes will be matched +against the basename of the path if it contains slashes. For example, +`a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. + +### nocomment + +Suppress the behavior of treating `#` at the start of a pattern as a +comment. + +### nonegate + +Suppress the behavior of treating a leading `!` character as negation. + +### flipNegate + +Returns from negate expressions the same as if they were not negated. +(Ie, true on a hit, false on a miss.) + +### partial + +Compare a partial path to a pattern. As long as the parts of the path that +are present are not contradicted by the pattern, it will be treated as a +match. This is useful in applications where you're walking through a +folder structure, and don't yet have the full path, but want to ensure that +you do not walk down paths that can never be a match. + +For example, + +```js +minimatch('/a/b', '/a/*/c/d', { partial: true }) // true, might be /a/b/c/d +minimatch('/a/b', '/**/d', { partial: true }) // true, might be /a/b/.../d +minimatch('/x/y/z', '/a/**/z', { partial: true }) // false, because x !== a +``` + +### windowsPathsNoEscape + +Use `\\` as a path separator _only_, and _never_ as an escape +character. If set, all `\\` characters are replaced with `/` in +the pattern. Note that this makes it **impossible** to match +against paths containing literal glob pattern characters, but +allows matching with patterns constructed using `path.join()` and +`path.resolve()` on Windows platforms, mimicking the (buggy!) +behavior of earlier versions on Windows. Please use with +caution, and be mindful of [the caveat about Windows +paths](#windows). + +For legacy reasons, this is also set if +`options.allowWindowsEscape` is set to the exact value `false`. + +## Comparisons to other fnmatch/glob implementations + +While strict compliance with the existing standards is a worthwhile +goal, some discrepancies exist between minimatch and other +implementations, and are intentional. + +If the pattern starts with a `!` character, then it is negated. Set the +`nonegate` flag to suppress this behavior, and treat leading `!` +characters normally. This is perhaps relevant if you wish to start the +pattern with a negative extglob pattern like `!(a|B)`. Multiple `!` +characters at the start of a pattern will negate the pattern multiple +times. + +If a pattern starts with `#`, then it is treated as a comment, and +will not match anything. Use `\#` to match a literal `#` at the +start of a line, or set the `nocomment` flag to suppress this behavior. + +The double-star character `**` is supported by default, unless the +`noglobstar` flag is set. This is supported in the manner of bsdglob +and bash 4.1, where `**` only has special significance if it is the only +thing in a path part. That is, `a/**/b` will match `a/x/y/b`, but +`a/**b` will not. + +If an escaped pattern has no matches, and the `nonull` flag is set, +then minimatch.match returns the pattern as-provided, rather than +interpreting the character escapes. For example, +`minimatch.match([], "\\*a\\?")` will return `"\\*a\\?"` rather than +`"*a?"`. This is akin to setting the `nullglob` option in bash, except +that it does not resolve escaped pattern characters. + +If brace expansion is not disabled, then it is performed before any +other interpretation of the glob pattern. Thus, a pattern like +`+(a|{b),c)}`, which would not be valid in bash or zsh, is expanded +**first** into the set of `+(a|b)` and `+(a|c)`, and those patterns are +checked for validity. Since those two are valid, matching proceeds. + +Note that `fnmatch(3)` in libc is an extremely naive string comparison +matcher, which does not do anything special for slashes. This library is +designed to be used in glob searching and file walkers, and so it does do +special things with `/`. Thus, `foo*` will not match `foo/bar` in this +library, even though it would in `fnmatch(3)`. diff --git a/tools/ui/node_modules/filelist/node_modules/minimatch/changelog.md b/tools/ui/node_modules/filelist/node_modules/minimatch/changelog.md new file mode 100644 index 0000000000000000000000000000000000000000..07decf76e641ab01e743dd6182081f41d02ae904 --- /dev/null +++ b/tools/ui/node_modules/filelist/node_modules/minimatch/changelog.md @@ -0,0 +1,35 @@ +# change log + +## 5.1 + +- use windowsPathNoEscape/allowWindowsEscape opts +- make character classes more faithful to bash glob behavior + - fix handling of escapes + - treat invalid character classes as non-matching pattern + rather than escaped literals + +## 5.0 + +- brace-expansion: ignore only blocks that begins with $ +- Expect exclusively forward slash as path sep, same as node-glob + +## 4.2 + +- makeRe: globstar should match zero+ path portions +- Fix bug with escaped '@' in patterns + +## 4.1 + +- treat `nocase:true` as always having magic +- expose GLOBSTAR marker + +## 4.0 + +- Update to modern JS syntax +- Add `allowWindowsEscape` option + +## 3.x + +- Added basic redos protection +- Handle unfinished `!(` extglob patterns +- Add `partial: true` option diff --git a/tools/ui/node_modules/filelist/node_modules/minimatch/lib/path.js b/tools/ui/node_modules/filelist/node_modules/minimatch/lib/path.js new file mode 100644 index 0000000000000000000000000000000000000000..ffe453d9e0557758c090f7053df5f426e172d84f --- /dev/null +++ b/tools/ui/node_modules/filelist/node_modules/minimatch/lib/path.js @@ -0,0 +1,4 @@ +const isWindows = typeof process === 'object' && + process && + process.platform === 'win32' +module.exports = isWindows ? { sep: '\\' } : { sep: '/' } diff --git a/tools/ui/node_modules/filelist/node_modules/minimatch/minimatch.js b/tools/ui/node_modules/filelist/node_modules/minimatch/minimatch.js new file mode 100644 index 0000000000000000000000000000000000000000..8545b3ab506a3185107a8f24a4c150a7b7b585f8 --- /dev/null +++ b/tools/ui/node_modules/filelist/node_modules/minimatch/minimatch.js @@ -0,0 +1,996 @@ +const minimatch = module.exports = (p, pattern, options = {}) => { + assertValidPattern(pattern) + + // shortcut: comments match nothing. + if (!options.nocomment && pattern.charAt(0) === '#') { + return false + } + + return new Minimatch(pattern, options).match(p) +} + +module.exports = minimatch + +const path = require('./lib/path.js') +minimatch.sep = path.sep + +const GLOBSTAR = Symbol('globstar **') +minimatch.GLOBSTAR = GLOBSTAR +const expand = require('brace-expansion') + +const plTypes = { + '!': { open: '(?:(?!(?:', close: '))[^/]*?)'}, + '?': { open: '(?:', close: ')?' }, + '+': { open: '(?:', close: ')+' }, + '*': { open: '(?:', close: ')*' }, + '@': { open: '(?:', close: ')' } +} + +// any single thing other than / +// don't need to escape / when using new RegExp() +const qmark = '[^/]' + +// * => any number of characters +const star = qmark + '*?' + +// ** when dots are allowed. Anything goes, except .. and . +// not (^ or / followed by one or two dots followed by $ or /), +// followed by anything, any number of times. +const twoStarDot = '(?:(?!(?:\\\/|^)(?:\\.{1,2})($|\\\/)).)*?' + +// not a ^ or / followed by a dot, +// followed by anything, any number of times. +const twoStarNoDot = '(?:(?!(?:\\\/|^)\\.).)*?' + +// "abc" -> { a:true, b:true, c:true } +const charSet = s => s.split('').reduce((set, c) => { + set[c] = true + return set +}, {}) + +// characters that need to be escaped in RegExp. +const reSpecials = charSet('().*{}+?[]^$\\!') + +// characters that indicate we have to add the pattern start +const addPatternStartSet = charSet('[.(') + +// normalizes slashes. +const slashSplit = /\/+/ + +minimatch.filter = (pattern, options = {}) => + (p, i, list) => minimatch(p, pattern, options) + +const ext = (a, b = {}) => { + const t = {} + Object.keys(a).forEach(k => t[k] = a[k]) + Object.keys(b).forEach(k => t[k] = b[k]) + return t +} + +minimatch.defaults = def => { + if (!def || typeof def !== 'object' || !Object.keys(def).length) { + return minimatch + } + + const orig = minimatch + + const m = (p, pattern, options) => orig(p, pattern, ext(def, options)) + m.Minimatch = class Minimatch extends orig.Minimatch { + constructor (pattern, options) { + super(pattern, ext(def, options)) + } + } + m.Minimatch.defaults = options => orig.defaults(ext(def, options)).Minimatch + m.filter = (pattern, options) => orig.filter(pattern, ext(def, options)) + m.defaults = options => orig.defaults(ext(def, options)) + m.makeRe = (pattern, options) => orig.makeRe(pattern, ext(def, options)) + m.braceExpand = (pattern, options) => orig.braceExpand(pattern, ext(def, options)) + m.match = (list, pattern, options) => orig.match(list, pattern, ext(def, options)) + + return m +} + + + + + +// Brace expansion: +// a{b,c}d -> abd acd +// a{b,}c -> abc ac +// a{0..3}d -> a0d a1d a2d a3d +// a{b,c{d,e}f}g -> abg acdfg acefg +// a{b,c}d{e,f}g -> abdeg acdeg abdeg abdfg +// +// Invalid sets are not expanded. +// a{2..}b -> a{2..}b +// a{b}c -> a{b}c +minimatch.braceExpand = (pattern, options) => braceExpand(pattern, options) + +const braceExpand = (pattern, options = {}) => { + assertValidPattern(pattern) + + // Thanks to Yeting Li for + // improving this regexp to avoid a ReDOS vulnerability. + if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) { + // shortcut. no need to expand. + return [pattern] + } + + return expand(pattern) +} + +const MAX_PATTERN_LENGTH = 1024 * 64 +const assertValidPattern = pattern => { + if (typeof pattern !== 'string') { + throw new TypeError('invalid pattern') + } + + if (pattern.length > MAX_PATTERN_LENGTH) { + throw new TypeError('pattern is too long') + } +} + +// parse a component of the expanded set. +// At this point, no pattern may contain "/" in it +// so we're going to return a 2d array, where each entry is the full +// pattern, split on '/', and then turned into a regular expression. +// A regexp is made at the end which joins each array with an +// escaped /, and another full one which joins each regexp with |. +// +// Following the lead of Bash 4.1, note that "**" only has special meaning +// when it is the *only* thing in a path portion. Otherwise, any series +// of * is equivalent to a single *. Globstar behavior is enabled by +// default, and can be disabled by setting options.noglobstar. +const SUBPARSE = Symbol('subparse') + +minimatch.makeRe = (pattern, options) => + new Minimatch(pattern, options || {}).makeRe() + +minimatch.match = (list, pattern, options = {}) => { + const mm = new Minimatch(pattern, options) + list = list.filter(f => mm.match(f)) + if (mm.options.nonull && !list.length) { + list.push(pattern) + } + return list +} + +// replace stuff like \* with * +const globUnescape = s => s.replace(/\\(.)/g, '$1') +const charUnescape = s => s.replace(/\\([^-\]])/g, '$1') +const regExpEscape = s => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&') +const braExpEscape = s => s.replace(/[[\]\\]/g, '\\$&') + +class Minimatch { + constructor (pattern, options) { + assertValidPattern(pattern) + + if (!options) options = {} + + this.options = options + this.maxGlobstarRecursion = options.maxGlobstarRecursion !== undefined + ? options.maxGlobstarRecursion : 200 + this.set = [] + this.pattern = pattern + this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || + options.allowWindowsEscape === false + if (this.windowsPathsNoEscape) { + this.pattern = this.pattern.replace(/\\/g, '/') + } + this.regexp = null + this.negate = false + this.comment = false + this.empty = false + this.partial = !!options.partial + + // make the set of regexps etc. + this.make() + } + + debug () {} + + make () { + const pattern = this.pattern + const options = this.options + + // empty patterns and comments match nothing. + if (!options.nocomment && pattern.charAt(0) === '#') { + this.comment = true + return + } + if (!pattern) { + this.empty = true + return + } + + // step 1: figure out negation, etc. + this.parseNegate() + + // step 2: expand braces + let set = this.globSet = this.braceExpand() + + if (options.debug) this.debug = (...args) => console.error(...args) + + this.debug(this.pattern, set) + + // step 3: now we have a set, so turn each one into a series of path-portion + // matching patterns. + // These will be regexps, except in the case of "**", which is + // set to the GLOBSTAR object for globstar behavior, + // and will not contain any / characters + set = this.globParts = set.map(s => s.split(slashSplit)) + + this.debug(this.pattern, set) + + // glob --> regexps + set = set.map((s, si, set) => s.map(this.parse, this)) + + this.debug(this.pattern, set) + + // filter out everything that didn't compile properly. + set = set.filter(s => s.indexOf(false) === -1) + + this.debug(this.pattern, set) + + this.set = set + } + + parseNegate () { + if (this.options.nonegate) return + + const pattern = this.pattern + let negate = false + let negateOffset = 0 + + for (let i = 0; i < pattern.length && pattern.charAt(i) === '!'; i++) { + negate = !negate + negateOffset++ + } + + if (negateOffset) this.pattern = pattern.slice(negateOffset) + this.negate = negate + } + + // set partial to true to test if, for example, + // "/a/b" matches the start of "/*/b/*/d" + // Partial means, if you run out of file before you run + // out of pattern, then that's fine, as long as all + // the parts match. + matchOne (file, pattern, partial) { + if (pattern.indexOf(GLOBSTAR) !== -1) { + return this._matchGlobstar(file, pattern, partial, 0, 0) + } + return this._matchOne(file, pattern, partial, 0, 0) + } + + _matchGlobstar (file, pattern, partial, fileIndex, patternIndex) { + // find first globstar from patternIndex + let firstgs = -1 + for (let i = patternIndex; i < pattern.length; i++) { + if (pattern[i] === GLOBSTAR) { firstgs = i; break } + } + + // find last globstar + let lastgs = -1 + for (let i = pattern.length - 1; i >= 0; i--) { + if (pattern[i] === GLOBSTAR) { lastgs = i; break } + } + + const head = pattern.slice(patternIndex, firstgs) + const body = partial ? pattern.slice(firstgs + 1) : pattern.slice(firstgs + 1, lastgs) + const tail = partial ? [] : pattern.slice(lastgs + 1) + + // check the head + if (head.length) { + const fileHead = file.slice(fileIndex, fileIndex + head.length) + if (!this._matchOne(fileHead, head, partial, 0, 0)) { + return false + } + fileIndex += head.length + } + + // check the tail + let fileTailMatch = 0 + if (tail.length) { + if (tail.length + fileIndex > file.length) return false + + const tailStart = file.length - tail.length + if (this._matchOne(file, tail, partial, tailStart, 0)) { + fileTailMatch = tail.length + } else { + // affordance for stuff like a/**/* matching a/b/ + if (file[file.length - 1] !== '' || + fileIndex + tail.length === file.length) { + return false + } + if (!this._matchOne(file, tail, partial, tailStart - 1, 0)) { + return false + } + fileTailMatch = tail.length + 1 + } + } + + // if body is empty (single ** between head and tail) + if (!body.length) { + let sawSome = !!fileTailMatch + for (let i = fileIndex; i < file.length - fileTailMatch; i++) { + const f = String(file[i]) + sawSome = true + if (f === '.' || f === '..' || + (!this.options.dot && f.charAt(0) === '.')) { + return false + } + } + return partial || sawSome + } + + // split body into segments at each GLOBSTAR + const bodySegments = [[[], 0]] + let currentBody = bodySegments[0] + let nonGsParts = 0 + const nonGsPartsSums = [0] + for (const b of body) { + if (b === GLOBSTAR) { + nonGsPartsSums.push(nonGsParts) + currentBody = [[], 0] + bodySegments.push(currentBody) + } else { + currentBody[0].push(b) + nonGsParts++ + } + } + + let idx = bodySegments.length - 1 + const fileLength = file.length - fileTailMatch + for (const b of bodySegments) { + b[1] = fileLength - (nonGsPartsSums[idx--] + b[0].length) + } + + return !!this._matchGlobStarBodySections( + file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch + ) + } + + // return false for "nope, not matching" + // return null for "not matching, cannot keep trying" + _matchGlobStarBodySections ( + file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail + ) { + const bs = bodySegments[bodyIndex] + if (!bs) { + // just make sure there are no bad dots + for (let i = fileIndex; i < file.length; i++) { + sawTail = true + const f = file[i] + if (f === '.' || f === '..' || + (!this.options.dot && f.charAt(0) === '.')) { + return false + } + } + return sawTail + } + + const [body, after] = bs + while (fileIndex <= after) { + const m = this._matchOne( + file.slice(0, fileIndex + body.length), + body, + partial, + fileIndex, + 0 + ) + // if limit exceeded, no match. intentional false negative, + // acceptable break in correctness for security. + if (m && globStarDepth < this.maxGlobstarRecursion) { + const sub = this._matchGlobStarBodySections( + file, bodySegments, + fileIndex + body.length, bodyIndex + 1, + partial, globStarDepth + 1, sawTail + ) + if (sub !== false) { + return sub + } + } + const f = file[fileIndex] + if (f === '.' || f === '..' || + (!this.options.dot && f.charAt(0) === '.')) { + return false + } + fileIndex++ + } + return partial || null + } + + _matchOne (file, pattern, partial, fileIndex, patternIndex) { + let fi, pi, fl, pl + for ( + fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length + ; (fi < fl) && (pi < pl) + ; fi++, pi++ + ) { + this.debug('matchOne loop') + const p = pattern[pi] + const f = file[fi] + + this.debug(pattern, p, f) + + // should be impossible. + // some invalid regexp stuff in the set. + /* istanbul ignore if */ + if (p === false || p === GLOBSTAR) return false + + // something other than ** + // non-magic patterns just have to match exactly + // patterns with magic have been turned into regexps. + let hit + if (typeof p === 'string') { + hit = f === p + this.debug('string match', p, f, hit) + } else { + hit = f.match(p) + this.debug('pattern match', p, f, hit) + } + + if (!hit) return false + } + + // now either we fell off the end of the pattern, or we're done. + if (fi === fl && pi === pl) { + // ran out of pattern and filename at the same time. + // an exact hit! + return true + } else if (fi === fl) { + // ran out of file, but still had pattern left. + // this is ok if we're doing the match as part of + // a glob fs traversal. + return partial + } else /* istanbul ignore else */ if (pi === pl) { + // ran out of pattern, still have file left. + // this is only acceptable if we're on the very last + // empty segment of a file with a trailing slash. + // a/* should match a/b/ + return (fi === fl - 1) && (file[fi] === '') + } + + // should be unreachable. + /* istanbul ignore next */ + throw new Error('wtf?') + } + + braceExpand () { + return braceExpand(this.pattern, this.options) + } + + parse (pattern, isSub) { + assertValidPattern(pattern) + + const options = this.options + + // shortcuts + if (pattern === '**') { + if (!options.noglobstar) + return GLOBSTAR + else + pattern = '*' + } + if (pattern === '') return '' + + let re = '' + let hasMagic = false + let escaping = false + // ? => one single character + const patternListStack = [] + const negativeLists = [] + let stateChar + let inClass = false + let reClassStart = -1 + let classStart = -1 + let cs + let pl + let sp + // . and .. never match anything that doesn't start with ., + // even when options.dot is set. However, if the pattern + // starts with ., then traversal patterns can match. + let dotTravAllowed = pattern.charAt(0) === '.' + let dotFileAllowed = options.dot || dotTravAllowed + const patternStart = () => + dotTravAllowed + ? '' + : dotFileAllowed + ? '(?!(?:^|\\/)\\.{1,2}(?:$|\\/))' + : '(?!\\.)' + const subPatternStart = (p) => + p.charAt(0) === '.' + ? '' + : options.dot + ? '(?!(?:^|\\/)\\.{1,2}(?:$|\\/))' + : '(?!\\.)' + + + const clearStateChar = () => { + if (stateChar) { + // we had some state-tracking character + // that wasn't consumed by this pass. + switch (stateChar) { + case '*': + re += star + hasMagic = true + break + case '?': + re += qmark + hasMagic = true + break + default: + re += '\\' + stateChar + break + } + this.debug('clearStateChar %j %j', stateChar, re) + stateChar = false + } + } + + for (let i = 0, c; (i < pattern.length) && (c = pattern.charAt(i)); i++) { + this.debug('%s\t%s %s %j', pattern, i, re, c) + + // skip over any that are escaped. + if (escaping) { + /* istanbul ignore next - completely not allowed, even escaped. */ + if (c === '/') { + return false + } + + if (reSpecials[c]) { + re += '\\' + } + re += c + escaping = false + continue + } + + switch (c) { + /* istanbul ignore next */ + case '/': { + // Should already be path-split by now. + return false + } + + case '\\': + if (inClass && pattern.charAt(i + 1) === '-') { + re += c + continue + } + + clearStateChar() + escaping = true + continue + + // the various stateChar values + // for the "extglob" stuff. + case '?': + case '*': + case '+': + case '@': + case '!': + this.debug('%s\t%s %s %j <-- stateChar', pattern, i, re, c) + + // all of those are literals inside a class, except that + // the glob [!a] means [^a] in regexp + if (inClass) { + this.debug(' in class') + if (c === '!' && i === classStart + 1) c = '^' + re += c + continue + } + + // coalesce consecutive non-globstar * characters + if (c === '*' && stateChar === '*') continue + + // if we already have a stateChar, then it means + // that there was something like ** or +? in there. + // Handle the stateChar, then proceed with this one. + this.debug('call clearStateChar %j', stateChar) + clearStateChar() + stateChar = c + // if extglob is disabled, then +(asdf|foo) isn't a thing. + // just clear the statechar *now*, rather than even diving into + // the patternList stuff. + if (options.noext) clearStateChar() + continue + + case '(': { + if (inClass) { + re += '(' + continue + } + + if (!stateChar) { + re += '\\(' + continue + } + + const plEntry = { + type: stateChar, + start: i - 1, + reStart: re.length, + open: plTypes[stateChar].open, + close: plTypes[stateChar].close, + } + this.debug(this.pattern, '\t', plEntry) + patternListStack.push(plEntry) + // negation is (?:(?!(?:js)(?:))[^/]*) + re += plEntry.open + // next entry starts with a dot maybe? + if (plEntry.start === 0 && plEntry.type !== '!') { + dotTravAllowed = true + re += subPatternStart(pattern.slice(i + 1)) + } + this.debug('plType %j %j', stateChar, re) + stateChar = false + continue + } + + case ')': { + const plEntry = patternListStack[patternListStack.length - 1] + if (inClass || !plEntry) { + re += '\\)' + continue + } + patternListStack.pop() + + // closing an extglob + clearStateChar() + hasMagic = true + pl = plEntry + // negation is (?:(?!js)[^/]*) + // The others are (?:) + re += pl.close + if (pl.type === '!') { + negativeLists.push(Object.assign(pl, { reEnd: re.length })) + } + continue + } + + case '|': { + const plEntry = patternListStack[patternListStack.length - 1] + if (inClass || !plEntry) { + re += '\\|' + continue + } + + clearStateChar() + re += '|' + // next subpattern can start with a dot? + if (plEntry.start === 0 && plEntry.type !== '!') { + dotTravAllowed = true + re += subPatternStart(pattern.slice(i + 1)) + } + continue + } + + // these are mostly the same in regexp and glob + case '[': + // swallow any state-tracking char before the [ + clearStateChar() + + if (inClass) { + re += '\\' + c + continue + } + + inClass = true + classStart = i + reClassStart = re.length + re += c + continue + + case ']': + // a right bracket shall lose its special + // meaning and represent itself in + // a bracket expression if it occurs + // first in the list. -- POSIX.2 2.8.3.2 + if (i === classStart + 1 || !inClass) { + re += '\\' + c + continue + } + + // split where the last [ was, make sure we don't have + // an invalid re. if so, re-walk the contents of the + // would-be class to re-translate any characters that + // were passed through as-is + // TODO: It would probably be faster to determine this + // without a try/catch and a new RegExp, but it's tricky + // to do safely. For now, this is safe and works. + cs = pattern.substring(classStart + 1, i) + try { + RegExp('[' + braExpEscape(charUnescape(cs)) + ']') + // looks good, finish up the class. + re += c + } catch (er) { + // out of order ranges in JS are errors, but in glob syntax, + // they're just a range that matches nothing. + re = re.substring(0, reClassStart) + '(?:$.)' // match nothing ever + } + hasMagic = true + inClass = false + continue + + default: + // swallow any state char that wasn't consumed + clearStateChar() + + if (reSpecials[c] && !(c === '^' && inClass)) { + re += '\\' + } + + re += c + break + + } // switch + } // for + + // handle the case where we left a class open. + // "[abc" is valid, equivalent to "\[abc" + if (inClass) { + // split where the last [ was, and escape it + // this is a huge pita. We now have to re-walk + // the contents of the would-be class to re-translate + // any characters that were passed through as-is + cs = pattern.slice(classStart + 1) + sp = this.parse(cs, SUBPARSE) + re = re.substring(0, reClassStart) + '\\[' + sp[0] + hasMagic = hasMagic || sp[1] + } + + // handle the case where we had a +( thing at the *end* + // of the pattern. + // each pattern list stack adds 3 chars, and we need to go through + // and escape any | chars that were passed through as-is for the regexp. + // Go through and escape them, taking care not to double-escape any + // | chars that were already escaped. + for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) { + let tail + tail = re.slice(pl.reStart + pl.open.length) + this.debug('setting tail', re, pl) + // maybe some even number of \, then maybe 1 \, followed by a | + tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_, $1, $2) => { + /* istanbul ignore else - should already be done */ + if (!$2) { + // the | isn't already escaped, so escape it. + $2 = '\\' + } + + // need to escape all those slashes *again*, without escaping the + // one that we need for escaping the | character. As it works out, + // escaping an even number of slashes can be done by simply repeating + // it exactly after itself. That's why this trick works. + // + // I am sorry that you have to see this. + return $1 + $1 + $2 + '|' + }) + + this.debug('tail=%j\n %s', tail, tail, pl, re) + const t = pl.type === '*' ? star + : pl.type === '?' ? qmark + : '\\' + pl.type + + hasMagic = true + re = re.slice(0, pl.reStart) + t + '\\(' + tail + } + + // handle trailing things that only matter at the very end. + clearStateChar() + if (escaping) { + // trailing \\ + re += '\\\\' + } + + // only need to apply the nodot start if the re starts with + // something that could conceivably capture a dot + const addPatternStart = addPatternStartSet[re.charAt(0)] + + // Hack to work around lack of negative lookbehind in JS + // A pattern like: *.!(x).!(y|z) needs to ensure that a name + // like 'a.xyz.yz' doesn't match. So, the first negative + // lookahead, has to look ALL the way ahead, to the end of + // the pattern. + for (let n = negativeLists.length - 1; n > -1; n--) { + const nl = negativeLists[n] + + const nlBefore = re.slice(0, nl.reStart) + const nlFirst = re.slice(nl.reStart, nl.reEnd - 8) + let nlAfter = re.slice(nl.reEnd) + const nlLast = re.slice(nl.reEnd - 8, nl.reEnd) + nlAfter + + // Handle nested stuff like *(*.js|!(*.json)), where open parens + // mean that we should *not* include the ) in the bit that is considered + // "after" the negated section. + const closeParensBefore = nlBefore.split(')').length + const openParensBefore = nlBefore.split('(').length - closeParensBefore + let cleanAfter = nlAfter + for (let i = 0; i < openParensBefore; i++) { + cleanAfter = cleanAfter.replace(/\)[+*?]?/, '') + } + nlAfter = cleanAfter + + const dollar = nlAfter === '' && isSub !== SUBPARSE ? '(?:$|\\/)' : '' + + re = nlBefore + nlFirst + nlAfter + dollar + nlLast + } + + // if the re is not "" at this point, then we need to make sure + // it doesn't match against an empty path part. + // Otherwise a/* will match a/, which it should not. + if (re !== '' && hasMagic) { + re = '(?=.)' + re + } + + if (addPatternStart) { + re = patternStart() + re + } + + // parsing just a piece of a larger pattern. + if (isSub === SUBPARSE) { + return [re, hasMagic] + } + + // if it's nocase, and the lcase/uppercase don't match, it's magic + if (options.nocase && !hasMagic) { + hasMagic = pattern.toUpperCase() !== pattern.toLowerCase() + } + + // skip the regexp for non-magical patterns + // unescape anything in it, though, so that it'll be + // an exact match against a file etc. + if (!hasMagic) { + return globUnescape(pattern) + } + + const flags = options.nocase ? 'i' : '' + try { + return Object.assign(new RegExp('^' + re + '$', flags), { + _glob: pattern, + _src: re, + }) + } catch (er) /* istanbul ignore next - should be impossible */ { + // If it was an invalid regular expression, then it can't match + // anything. This trick looks for a character after the end of + // the string, which is of course impossible, except in multi-line + // mode, but it's not a /m regex. + return new RegExp('$.') + } + } + + makeRe () { + if (this.regexp || this.regexp === false) return this.regexp + + // at this point, this.set is a 2d array of partial + // pattern strings, or "**". + // + // It's better to use .match(). This function shouldn't + // be used, really, but it's pretty convenient sometimes, + // when you just want to work with a regex. + const set = this.set + + if (!set.length) { + this.regexp = false + return this.regexp + } + const options = this.options + + const twoStar = options.noglobstar ? star + : options.dot ? twoStarDot + : twoStarNoDot + const flags = options.nocase ? 'i' : '' + + // coalesce globstars and regexpify non-globstar patterns + // if it's the only item, then we just do one twoStar + // if it's the first, and there are more, prepend (\/|twoStar\/)? to next + // if it's the last, append (\/twoStar|) to previous + // if it's in the middle, append (\/|\/twoStar\/) to previous + // then filter out GLOBSTAR symbols + let re = set.map(pattern => { + pattern = pattern.map(p => + typeof p === 'string' ? regExpEscape(p) + : p === GLOBSTAR ? GLOBSTAR + : p._src + ).reduce((set, p) => { + if (!(set[set.length - 1] === GLOBSTAR && p === GLOBSTAR)) { + set.push(p) + } + return set + }, []) + pattern.forEach((p, i) => { + if (p !== GLOBSTAR || pattern[i-1] === GLOBSTAR) { + return + } + if (i === 0) { + if (pattern.length > 1) { + pattern[i+1] = '(?:\\\/|' + twoStar + '\\\/)?' + pattern[i+1] + } else { + pattern[i] = twoStar + } + } else if (i === pattern.length - 1) { + pattern[i-1] += '(?:\\\/|' + twoStar + ')?' + } else { + pattern[i-1] += '(?:\\\/|\\\/' + twoStar + '\\\/)' + pattern[i+1] + pattern[i+1] = GLOBSTAR + } + }) + return pattern.filter(p => p !== GLOBSTAR).join('/') + }).join('|') + + // must match entire pattern + // ending in a * or ** will make it less strict. + re = '^(?:' + re + ')$' + + // can match anything, as long as it's not this. + if (this.negate) re = '^(?!' + re + ').*$' + + try { + this.regexp = new RegExp(re, flags) + } catch (ex) /* istanbul ignore next - should be impossible */ { + this.regexp = false + } + return this.regexp + } + + match (f, partial = this.partial) { + this.debug('match', f, this.pattern) + // short-circuit in the case of busted things. + // comments, etc. + if (this.comment) return false + if (this.empty) return f === '' + + if (f === '/' && partial) return true + + const options = this.options + + // windows: need to use /, not \ + if (path.sep !== '/') { + f = f.split(path.sep).join('/') + } + + // treat the test path as a set of pathparts. + f = f.split(slashSplit) + this.debug(this.pattern, 'split', f) + + // just ONE of the pattern sets in this.set needs to match + // in order for it to be valid. If negating, then just one + // match means that we have failed. + // Either way, return on the first hit. + + const set = this.set + this.debug(this.pattern, 'set', set) + + // Find the basename of the path by looking for the last non-empty segment + let filename + for (let i = f.length - 1; i >= 0; i--) { + filename = f[i] + if (filename) break + } + + for (let i = 0; i < set.length; i++) { + const pattern = set[i] + let file = f + if (options.matchBase && pattern.length === 1) { + file = [filename] + } + const hit = this.matchOne(file, pattern, partial) + if (hit) { + if (options.flipNegate) return true + return !this.negate + } + } + + // didn't get any hits. this is success if it's a negative + // pattern, failure otherwise. + if (options.flipNegate) return false + return this.negate + } + + static defaults (def) { + return minimatch.defaults(def).Minimatch + } +} + +minimatch.Minimatch = Minimatch diff --git a/tools/ui/node_modules/filelist/node_modules/minimatch/package.json b/tools/ui/node_modules/filelist/node_modules/minimatch/package.json new file mode 100644 index 0000000000000000000000000000000000000000..cac30abe1bcb6cfe3de5d1999b10f68f880d15a3 --- /dev/null +++ b/tools/ui/node_modules/filelist/node_modules/minimatch/package.json @@ -0,0 +1,35 @@ +{ + "author": "Isaac Z. Schlueter (http://blog.izs.me)", + "name": "minimatch", + "description": "a glob matcher in javascript", + "publishConfig": { + "tag": "legacy-v5" + }, + "version": "5.1.9", + "repository": { + "type": "git", + "url": "git://github.com/isaacs/minimatch.git" + }, + "main": "minimatch.js", + "scripts": { + "test": "tap", + "snap": "tap", + "preversion": "npm test", + "postversion": "npm publish", + "prepublishOnly": "git push origin --follow-tags" + }, + "engines": { + "node": ">=10" + }, + "dependencies": { + "brace-expansion": "^2.0.1" + }, + "devDependencies": { + "tap": "^16.3.2" + }, + "license": "ISC", + "files": [ + "minimatch.js", + "lib" + ] +} diff --git a/tools/ui/node_modules/filelist/package.json b/tools/ui/node_modules/filelist/package.json new file mode 100644 index 0000000000000000000000000000000000000000..940b57db80048daaa25cf0500e8edd6d074ef2ee --- /dev/null +++ b/tools/ui/node_modules/filelist/package.json @@ -0,0 +1,28 @@ +{ + "name": "filelist", + "version": "1.0.6", + "description": "Lazy-evaluating list of files, based on globs or regex patterns", + "main": "index.js", + "types": "index.d.ts", + "scripts": { + "test": "jake test" + }, + "repository": { + "type": "git", + "url": "git://github.com/mde/filelist.git" + }, + "keywords": [ + "file", + "utility", + "glob" + ], + "author": "Matthew Eernisse (http://fleegix.org)", + "license": "Apache-2.0", + "bugs": { + "url": "https://github.com/mde/filelist/issues" + }, + "homepage": "https://github.com/mde/filelist", + "dependencies": { + "minimatch": "^5.0.1" + } +} diff --git a/tools/ui/node_modules/finalhandler/HISTORY.md b/tools/ui/node_modules/finalhandler/HISTORY.md new file mode 100644 index 0000000000000000000000000000000000000000..8b011be00a99399ac5c79dac3251efa5964907cf --- /dev/null +++ b/tools/ui/node_modules/finalhandler/HISTORY.md @@ -0,0 +1,239 @@ +v2.1.1. / 2025-12-01 +================== + +* update engines field in the package.json to reflect the current compatibility (Node <18). See: 2.0.0 +* Minor changes (package metadata) + +v2.1.0 / 2025-03-05 +================== + + * deps: + * use caret notation for dependency versions + * encodeurl@^2.0.0 + * debug@^4.4.0 + * remove `ServerResponse.headersSent` support check + * remove setImmediate support check + * update test dependencies + * remove unnecessary devDependency `safe-buffer` + * remove `unpipe` package and use native `unpipe()` method + * remove unnecessary devDependency `readable-stream` + * refactor: use object spread to copy error headers + * refactor: use replaceAll instead of replace with a regex + * refactor: replace setHeaders function with optimized inline header setting + +v2.0.0 / 2024-09-02 +================== + + * drop support for node <18 + * ignore status message for HTTP/2 (#53) + +v1.3.1 / 2024-09-11 +================== + + * deps: encodeurl@~2.0.0 + +v1.3.0 / 2024-09-03 +================== + + * ignore status message for HTTP/2 (#53) + +v1.2.1 / 2024-09-02 +================== + + * Gracefully handle when handling an error and socket is null + +1.2.0 / 2022-03-22 +================== + + * Remove set content headers that break response + * deps: on-finished@2.4.1 + * deps: statuses@2.0.1 + - Rename `425 Unordered Collection` to standard `425 Too Early` + +1.1.2 / 2019-05-09 +================== + + * Set stricter `Content-Security-Policy` header + * deps: parseurl@~1.3.3 + * deps: statuses@~1.5.0 + +1.1.1 / 2018-03-06 +================== + + * Fix 404 output for bad / missing pathnames + * deps: encodeurl@~1.0.2 + - Fix encoding `%` as last character + * deps: statuses@~1.4.0 + +1.1.0 / 2017-09-24 +================== + + * Use `res.headersSent` when available + +1.0.6 / 2017-09-22 +================== + + * deps: debug@2.6.9 + +1.0.5 / 2017-09-15 +================== + + * deps: parseurl@~1.3.2 + - perf: reduce overhead for full URLs + - perf: unroll the "fast-path" `RegExp` + +1.0.4 / 2017-08-03 +================== + + * deps: debug@2.6.8 + +1.0.3 / 2017-05-16 +================== + + * deps: debug@2.6.7 + - deps: ms@2.0.0 + +1.0.2 / 2017-04-22 +================== + + * deps: debug@2.6.4 + - deps: ms@0.7.3 + +1.0.1 / 2017-03-21 +================== + + * Fix missing `` in HTML document + * deps: debug@2.6.3 + - Fix: `DEBUG_MAX_ARRAY_LENGTH` + +1.0.0 / 2017-02-15 +================== + + * Fix exception when `err` cannot be converted to a string + * Fully URL-encode the pathname in the 404 message + * Only include the pathname in the 404 message + * Send complete HTML document + * Set `Content-Security-Policy: default-src 'self'` header + * deps: debug@2.6.1 + - Allow colors in workers + - Deprecated `DEBUG_FD` environment variable set to `3` or higher + - Fix error when running under React Native + - Use same color for same namespace + - deps: ms@0.7.2 + +0.5.1 / 2016-11-12 +================== + + * Fix exception when `err.headers` is not an object + * deps: statuses@~1.3.1 + * perf: hoist regular expressions + * perf: remove duplicate validation path + +0.5.0 / 2016-06-15 +================== + + * Change invalid or non-numeric status code to 500 + * Overwrite status message to match set status code + * Prefer `err.statusCode` if `err.status` is invalid + * Set response headers from `err.headers` object + * Use `statuses` instead of `http` module for status messages + - Includes all defined status messages + +0.4.1 / 2015-12-02 +================== + + * deps: escape-html@~1.0.3 + - perf: enable strict mode + - perf: optimize string replacement + - perf: use faster string coercion + +0.4.0 / 2015-06-14 +================== + + * Fix a false-positive when unpiping in Node.js 0.8 + * Support `statusCode` property on `Error` objects + * Use `unpipe` module for unpiping requests + * deps: escape-html@1.0.2 + * deps: on-finished@~2.3.0 + - Add defined behavior for HTTP `CONNECT` requests + - Add defined behavior for HTTP `Upgrade` requests + - deps: ee-first@1.1.1 + * perf: enable strict mode + * perf: remove argument reassignment + +0.3.6 / 2015-05-11 +================== + + * deps: debug@~2.2.0 + - deps: ms@0.7.1 + +0.3.5 / 2015-04-22 +================== + + * deps: on-finished@~2.2.1 + - Fix `isFinished(req)` when data buffered + +0.3.4 / 2015-03-15 +================== + + * deps: debug@~2.1.3 + - Fix high intensity foreground color for bold + - deps: ms@0.7.0 + +0.3.3 / 2015-01-01 +================== + + * deps: debug@~2.1.1 + * deps: on-finished@~2.2.0 + +0.3.2 / 2014-10-22 +================== + + * deps: on-finished@~2.1.1 + - Fix handling of pipelined requests + +0.3.1 / 2014-10-16 +================== + + * deps: debug@~2.1.0 + - Implement `DEBUG_FD` env variable support + +0.3.0 / 2014-09-17 +================== + + * Terminate in progress response only on error + * Use `on-finished` to determine request status + +0.2.0 / 2014-09-03 +================== + + * Set `X-Content-Type-Options: nosniff` header + * deps: debug@~2.0.0 + +0.1.0 / 2014-07-16 +================== + + * Respond after request fully read + - prevents hung responses and socket hang ups + * deps: debug@1.0.4 + +0.0.3 / 2014-07-11 +================== + + * deps: debug@1.0.3 + - Add support for multiple wildcards in namespaces + +0.0.2 / 2014-06-19 +================== + + * Handle invalid status codes + +0.0.1 / 2014-06-05 +================== + + * deps: debug@1.0.2 + +0.0.0 / 2014-06-05 +================== + + * Extracted from connect/express diff --git a/tools/ui/node_modules/finalhandler/LICENSE b/tools/ui/node_modules/finalhandler/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..60221067c4d591554407b4700033aab9669a9b0e --- /dev/null +++ b/tools/ui/node_modules/finalhandler/LICENSE @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2014-2022 Douglas Christopher Wilson + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/finalhandler/README.md b/tools/ui/node_modules/finalhandler/README.md new file mode 100644 index 0000000000000000000000000000000000000000..e40f729a10085463adc71b4772c2d988bae6f25f --- /dev/null +++ b/tools/ui/node_modules/finalhandler/README.md @@ -0,0 +1,150 @@ +# finalhandler + +[![NPM Version][npm-image]][npm-url] +[![NPM Downloads][downloads-image]][downloads-url] +[![Node.js Version][node-image]][node-url] +[![Build Status][github-actions-ci-image]][github-actions-ci-url] +[![Test Coverage][coveralls-image]][coveralls-url] +[![OpenSSF Scorecard Badge][ossf-scorecard-badge]][ossf-scorecard-visualizer] + +Node.js function to invoke as the final step to respond to HTTP request. + +## Installation + +This is a [Node.js](https://nodejs.org/en/) module available through the +[npm registry](https://www.npmjs.com/). Installation is done using the +[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally): + +```sh +$ npm install finalhandler +``` + +## API + +```js +const finalhandler = require('finalhandler') +``` + +### finalhandler(req, res, [options]) + +Returns function to be invoked as the final step for the given `req` and `res`. +This function is to be invoked as `fn(err)`. If `err` is falsy, the handler will +write out a 404 response to the `res`. If it is truthy, an error response will +be written out to the `res` or `res` will be terminated if a response has already +started. + +When an error is written, the following information is added to the response: + + * The `res.statusCode` is set from `err.status` (or `err.statusCode`). If + this value is outside the 4xx or 5xx range, it will be set to 500. + * The `res.statusMessage` is set according to the status code. + * The body will be the HTML of the status code message if `env` is + `'production'`, otherwise will be `err.stack`. + * Any headers specified in an `err.headers` object. + +The final handler will also unpipe anything from `req` when it is invoked. + +#### options.env + +By default, the environment is determined by `NODE_ENV` variable, but it can be +overridden by this option. + +#### options.onerror + +Provide a function to be called with the `err` when it exists. Can be used for +writing errors to a central location without excessive function generation. Called +as `onerror(err, req, res)`. + +## Examples + +### always 404 + +```js +const finalhandler = require('finalhandler') +const http = require('http') + +const server = http.createServer((req, res) => { + const done = finalhandler(req, res) + done() +}) + +server.listen(3000) +``` + +### perform simple action + +```js +const finalhandler = require('finalhandler') +const fs = require('fs') +const http = require('http') + +const server = http.createServer((req, res) => { + const done = finalhandler(req, res) + + fs.readFile('index.html', (err, buf) => { + if (err) return done(err) + res.setHeader('Content-Type', 'text/html') + res.end(buf) + }) +}) + +server.listen(3000) +``` + +### use with middleware-style functions + +```js +const finalhandler = require('finalhandler') +const http = require('http') +const serveStatic = require('serve-static') + +const serve = serveStatic('public') + +const server = http.createServer((req, res) => { + const done = finalhandler(req, res) + serve(req, res, done) +}) + +server.listen(3000) +``` + +### keep log of all errors + +```js +const finalhandler = require('finalhandler') +const fs = require('fs') +const http = require('http') + +const server = http.createServer((req, res) => { + const done = finalhandler(req, res, { onerror: logerror }) + + fs.readFile('index.html', (err, buf) => { + if (err) return done(err) + res.setHeader('Content-Type', 'text/html') + res.end(buf) + }) +}) + +server.listen(3000) + +function logerror (err) { + console.error(err.stack || err.toString()) +} +``` + +## License + +[MIT](LICENSE) + +[npm-image]: https://img.shields.io/npm/v/finalhandler.svg +[npm-url]: https://npmjs.org/package/finalhandler +[node-image]: https://img.shields.io/node/v/finalhandler.svg +[node-url]: https://nodejs.org/en/download +[coveralls-image]: https://img.shields.io/coveralls/pillarjs/finalhandler.svg +[coveralls-url]: https://coveralls.io/r/pillarjs/finalhandler?branch=master +[downloads-image]: https://img.shields.io/npm/dm/finalhandler.svg +[downloads-url]: https://npmjs.org/package/finalhandler +[github-actions-ci-image]: https://github.com/pillarjs/finalhandler/actions/workflows/ci.yml/badge.svg +[github-actions-ci-url]: https://github.com/pillarjs/finalhandler/actions/workflows/ci.yml +[ossf-scorecard-badge]: https://api.scorecard.dev/projects/github.com/pillarjs/finalhandler/badge +[ossf-scorecard-visualizer]: https://ossf.github.io/scorecard-visualizer/#/projects/github.com/pillarjs/finalhandler \ No newline at end of file diff --git a/tools/ui/node_modules/finalhandler/index.js b/tools/ui/node_modules/finalhandler/index.js new file mode 100644 index 0000000000000000000000000000000000000000..bf15e484c8f40a242f5fbf24676bda8da0e9e013 --- /dev/null +++ b/tools/ui/node_modules/finalhandler/index.js @@ -0,0 +1,293 @@ +/*! + * finalhandler + * Copyright(c) 2014-2022 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * Module dependencies. + * @private + */ + +var debug = require('debug')('finalhandler') +var encodeUrl = require('encodeurl') +var escapeHtml = require('escape-html') +var onFinished = require('on-finished') +var parseUrl = require('parseurl') +var statuses = require('statuses') + +/** + * Module variables. + * @private + */ + +var isFinished = onFinished.isFinished + +/** + * Create a minimal HTML document. + * + * @param {string} message + * @private + */ + +function createHtmlDocument (message) { + var body = escapeHtml(message) + .replaceAll('\n', '
') + .replaceAll(' ', '  ') + + return '\n' + + '\n' + + '\n' + + '\n' + + 'Error\n' + + '\n' + + '\n' + + '
' + body + '
\n' + + '\n' + + '\n' +} + +/** + * Module exports. + * @public + */ + +module.exports = finalhandler + +/** + * Create a function to handle the final response. + * + * @param {Request} req + * @param {Response} res + * @param {Object} [options] + * @return {Function} + * @public + */ + +function finalhandler (req, res, options) { + var opts = options || {} + + // get environment + var env = opts.env || process.env.NODE_ENV || 'development' + + // get error callback + var onerror = opts.onerror + + return function (err) { + var headers + var msg + var status + + // ignore 404 on in-flight response + if (!err && res.headersSent) { + debug('cannot 404 after headers sent') + return + } + + // unhandled error + if (err) { + // respect status code from error + status = getErrorStatusCode(err) + + if (status === undefined) { + // fallback to status code on response + status = getResponseStatusCode(res) + } else { + // respect headers from error + headers = getErrorHeaders(err) + } + + // get error message + msg = getErrorMessage(err, status, env) + } else { + // not found + status = 404 + msg = 'Cannot ' + req.method + ' ' + encodeUrl(getResourceName(req)) + } + + debug('default %s', status) + + // schedule onerror callback + if (err && onerror) { + setImmediate(onerror, err, req, res) + } + + // cannot actually respond + if (res.headersSent) { + debug('cannot %d after headers sent', status) + if (req.socket) { + req.socket.destroy() + } + return + } + + // send response + send(req, res, status, headers, msg) + } +} + +/** + * Get headers from Error object. + * + * @param {Error} err + * @return {object} + * @private + */ + +function getErrorHeaders (err) { + if (!err.headers || typeof err.headers !== 'object') { + return undefined + } + + return { ...err.headers } +} + +/** + * Get message from Error object, fallback to status message. + * + * @param {Error} err + * @param {number} status + * @param {string} env + * @return {string} + * @private + */ + +function getErrorMessage (err, status, env) { + var msg + + if (env !== 'production') { + // use err.stack, which typically includes err.message + msg = err.stack + + // fallback to err.toString() when possible + if (!msg && typeof err.toString === 'function') { + msg = err.toString() + } + } + + return msg || statuses.message[status] +} + +/** + * Get status code from Error object. + * + * @param {Error} err + * @return {number} + * @private + */ + +function getErrorStatusCode (err) { + // check err.status + if (typeof err.status === 'number' && err.status >= 400 && err.status < 600) { + return err.status + } + + // check err.statusCode + if (typeof err.statusCode === 'number' && err.statusCode >= 400 && err.statusCode < 600) { + return err.statusCode + } + + return undefined +} + +/** + * Get resource name for the request. + * + * This is typically just the original pathname of the request + * but will fallback to "resource" is that cannot be determined. + * + * @param {IncomingMessage} req + * @return {string} + * @private + */ + +function getResourceName (req) { + try { + return parseUrl.original(req).pathname + } catch (e) { + return 'resource' + } +} + +/** + * Get status code from response. + * + * @param {OutgoingMessage} res + * @return {number} + * @private + */ + +function getResponseStatusCode (res) { + var status = res.statusCode + + // default status code to 500 if outside valid range + if (typeof status !== 'number' || status < 400 || status > 599) { + status = 500 + } + + return status +} + +/** + * Send response. + * + * @param {IncomingMessage} req + * @param {OutgoingMessage} res + * @param {number} status + * @param {object} headers + * @param {string} message + * @private + */ + +function send (req, res, status, headers, message) { + function write () { + // response body + var body = createHtmlDocument(message) + + // response status + res.statusCode = status + + if (req.httpVersionMajor < 2) { + res.statusMessage = statuses.message[status] + } + + // remove any content headers + res.removeHeader('Content-Encoding') + res.removeHeader('Content-Language') + res.removeHeader('Content-Range') + + // response headers + for (const [key, value] of Object.entries(headers ?? {})) { + res.setHeader(key, value) + } + + // security headers + res.setHeader('Content-Security-Policy', "default-src 'none'") + res.setHeader('X-Content-Type-Options', 'nosniff') + + // standard headers + res.setHeader('Content-Type', 'text/html; charset=utf-8') + res.setHeader('Content-Length', Buffer.byteLength(body, 'utf8')) + + if (req.method === 'HEAD') { + res.end() + return + } + + res.end(body, 'utf8') + } + + if (isFinished(req)) { + write() + return + } + + // unpipe everything from the request + req.unpipe() + + // flush the request + onFinished(req, write) + req.resume() +} diff --git a/tools/ui/node_modules/finalhandler/package.json b/tools/ui/node_modules/finalhandler/package.json new file mode 100644 index 0000000000000000000000000000000000000000..869ddc2b39e2a68f60559e77f7204403c39e7d90 --- /dev/null +++ b/tools/ui/node_modules/finalhandler/package.json @@ -0,0 +1,47 @@ +{ + "name": "finalhandler", + "description": "Node.js final http responder", + "version": "2.1.1", + "author": "Douglas Christopher Wilson ", + "license": "MIT", + "repository": "pillarjs/finalhandler", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/express" + }, + "dependencies": { + "debug": "^4.4.0", + "encodeurl": "^2.0.0", + "escape-html": "^1.0.3", + "on-finished": "^2.4.1", + "parseurl": "^1.3.3", + "statuses": "^2.0.1" + }, + "devDependencies": { + "eslint": "^7.32.0", + "eslint-config-standard": "^14.1.1", + "eslint-plugin-import": "^2.31.0", + "eslint-plugin-markdown": "^2.2.1", + "eslint-plugin-node": "^11.1.0", + "eslint-plugin-promise": "^5.2.0", + "eslint-plugin-standard": "^4.1.0", + "mocha": "^11.0.1", + "nyc": "^17.1.0", + "supertest": "^7.0.0" + }, + "files": [ + "LICENSE", + "HISTORY.md", + "index.js" + ], + "engines": { + "node": ">= 18.0.0" + }, + "scripts": { + "lint": "eslint .", + "test": "mocha --reporter spec --check-leaks test/", + "test-ci": "nyc --reporter=lcovonly --reporter=text npm test", + "test-cov": "nyc --reporter=html --reporter=text npm test", + "test-inspect": "mocha --reporter spec --inspect --inspect-brk test/" + } +} diff --git a/tools/ui/node_modules/find-up/index.d.ts b/tools/ui/node_modules/find-up/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6746bb72914a50141a945dea03ace0b5fc8ecd29 --- /dev/null +++ b/tools/ui/node_modules/find-up/index.d.ts @@ -0,0 +1,138 @@ +/* eslint-disable @typescript-eslint/unified-signatures */ +import {Options as LocatePathOptions} from 'locate-path'; + +declare const stop: unique symbol; + +declare namespace findUp { + interface Options extends LocatePathOptions {} + + type StopSymbol = typeof stop; + + type Match = string | StopSymbol | undefined; +} + +declare const findUp: { + sync: { + /** + Synchronously check if a path exists. + + @param path - Path to the file or directory. + @returns Whether the path exists. + + @example + ``` + import findUp = require('find-up'); + + console.log(findUp.sync.exists('/Users/sindresorhus/unicorn.png')); + //=> true + ``` + */ + exists: (path: string) => boolean; + + /** + Synchronously find a file or directory by walking up parent directories. + + @param name - Name of the file or directory to find. Can be multiple. + @returns The first path found (by respecting the order of `name`s) or `undefined` if none could be found. + */ + (name: string | readonly string[], options?: findUp.Options): string | undefined; + + /** + Synchronously find a file or directory by walking up parent directories. + + @param matcher - Called for each directory in the search. Return a path or `findUp.stop` to stop the search. + @returns The first path found or `undefined` if none could be found. + + @example + ``` + import path = require('path'); + import findUp = require('find-up'); + + console.log(findUp.sync(directory => { + const hasUnicorns = findUp.sync.exists(path.join(directory, 'unicorn.png')); + return hasUnicorns && directory; + }, {type: 'directory'})); + //=> '/Users/sindresorhus' + ``` + */ + (matcher: (directory: string) => findUp.Match, options?: findUp.Options): string | undefined; + }; + + /** + Check if a path exists. + + @param path - Path to a file or directory. + @returns Whether the path exists. + + @example + ``` + import findUp = require('find-up'); + + (async () => { + console.log(await findUp.exists('/Users/sindresorhus/unicorn.png')); + //=> true + })(); + ``` + */ + exists: (path: string) => Promise; + + /** + Return this in a `matcher` function to stop the search and force `findUp` to immediately return `undefined`. + */ + readonly stop: findUp.StopSymbol; + + /** + Find a file or directory by walking up parent directories. + + @param name - Name of the file or directory to find. Can be multiple. + @returns The first path found (by respecting the order of `name`s) or `undefined` if none could be found. + + @example + ``` + // / + // └── Users + // └── sindresorhus + // ├── unicorn.png + // └── foo + // └── bar + // ├── baz + // └── example.js + + // example.js + import findUp = require('find-up'); + + (async () => { + console.log(await findUp('unicorn.png')); + //=> '/Users/sindresorhus/unicorn.png' + + console.log(await findUp(['rainbow.png', 'unicorn.png'])); + //=> '/Users/sindresorhus/unicorn.png' + })(); + ``` + */ + (name: string | readonly string[], options?: findUp.Options): Promise; + + /** + Find a file or directory by walking up parent directories. + + @param matcher - Called for each directory in the search. Return a path or `findUp.stop` to stop the search. + @returns The first path found or `undefined` if none could be found. + + @example + ``` + import path = require('path'); + import findUp = require('find-up'); + + (async () => { + console.log(await findUp(async directory => { + const hasUnicorns = await findUp.exists(path.join(directory, 'unicorn.png')); + return hasUnicorns && directory; + }, {type: 'directory'})); + //=> '/Users/sindresorhus' + })(); + ``` + */ + (matcher: (directory: string) => (findUp.Match | Promise), options?: findUp.Options): Promise; +}; + +export = findUp; diff --git a/tools/ui/node_modules/find-up/index.js b/tools/ui/node_modules/find-up/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ce564e5d322847ed088eba6d0973c19da3b4426d --- /dev/null +++ b/tools/ui/node_modules/find-up/index.js @@ -0,0 +1,89 @@ +'use strict'; +const path = require('path'); +const locatePath = require('locate-path'); +const pathExists = require('path-exists'); + +const stop = Symbol('findUp.stop'); + +module.exports = async (name, options = {}) => { + let directory = path.resolve(options.cwd || ''); + const {root} = path.parse(directory); + const paths = [].concat(name); + + const runMatcher = async locateOptions => { + if (typeof name !== 'function') { + return locatePath(paths, locateOptions); + } + + const foundPath = await name(locateOptions.cwd); + if (typeof foundPath === 'string') { + return locatePath([foundPath], locateOptions); + } + + return foundPath; + }; + + // eslint-disable-next-line no-constant-condition + while (true) { + // eslint-disable-next-line no-await-in-loop + const foundPath = await runMatcher({...options, cwd: directory}); + + if (foundPath === stop) { + return; + } + + if (foundPath) { + return path.resolve(directory, foundPath); + } + + if (directory === root) { + return; + } + + directory = path.dirname(directory); + } +}; + +module.exports.sync = (name, options = {}) => { + let directory = path.resolve(options.cwd || ''); + const {root} = path.parse(directory); + const paths = [].concat(name); + + const runMatcher = locateOptions => { + if (typeof name !== 'function') { + return locatePath.sync(paths, locateOptions); + } + + const foundPath = name(locateOptions.cwd); + if (typeof foundPath === 'string') { + return locatePath.sync([foundPath], locateOptions); + } + + return foundPath; + }; + + // eslint-disable-next-line no-constant-condition + while (true) { + const foundPath = runMatcher({...options, cwd: directory}); + + if (foundPath === stop) { + return; + } + + if (foundPath) { + return path.resolve(directory, foundPath); + } + + if (directory === root) { + return; + } + + directory = path.dirname(directory); + } +}; + +module.exports.exists = pathExists; + +module.exports.sync.exists = pathExists.sync; + +module.exports.stop = stop; diff --git a/tools/ui/node_modules/find-up/license b/tools/ui/node_modules/find-up/license new file mode 100644 index 0000000000000000000000000000000000000000..fa7ceba3eb4a9657a9db7f3ffca4e4e97a9019de --- /dev/null +++ b/tools/ui/node_modules/find-up/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/find-up/package.json b/tools/ui/node_modules/find-up/package.json new file mode 100644 index 0000000000000000000000000000000000000000..56db6dd80a8e93d03c0f4e2ed4c34926c513b051 --- /dev/null +++ b/tools/ui/node_modules/find-up/package.json @@ -0,0 +1,54 @@ +{ + "name": "find-up", + "version": "5.0.0", + "description": "Find a file or directory by walking up parent directories", + "license": "MIT", + "repository": "sindresorhus/find-up", + "funding": "https://github.com/sponsors/sindresorhus", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "engines": { + "node": ">=10" + }, + "scripts": { + "test": "xo && ava && tsd" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "find", + "up", + "find-up", + "findup", + "look-up", + "look", + "file", + "search", + "match", + "package", + "resolve", + "parent", + "parents", + "folder", + "directory", + "walk", + "walking", + "path" + ], + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "devDependencies": { + "ava": "^2.1.0", + "is-path-inside": "^2.1.0", + "tempy": "^0.6.0", + "tsd": "^0.13.1", + "xo": "^0.33.0" + } +} diff --git a/tools/ui/node_modules/find-up/readme.md b/tools/ui/node_modules/find-up/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..7ad908a7ce31b6f95fc7f2fbd6e959d118f79943 --- /dev/null +++ b/tools/ui/node_modules/find-up/readme.md @@ -0,0 +1,151 @@ +# find-up [![Build Status](https://travis-ci.com/sindresorhus/find-up.svg?branch=master)](https://travis-ci.com/github/sindresorhus/find-up) + +> Find a file or directory by walking up parent directories + +## Install + +``` +$ npm install find-up +``` + +## Usage + +``` +/ +└── Users + └── sindresorhus + ├── unicorn.png + └── foo + └── bar + ├── baz + └── example.js +``` + +`example.js` + +```js +const path = require('path'); +const findUp = require('find-up'); + +(async () => { + console.log(await findUp('unicorn.png')); + //=> '/Users/sindresorhus/unicorn.png' + + console.log(await findUp(['rainbow.png', 'unicorn.png'])); + //=> '/Users/sindresorhus/unicorn.png' + + console.log(await findUp(async directory => { + const hasUnicorns = await findUp.exists(path.join(directory, 'unicorn.png')); + return hasUnicorns && directory; + }, {type: 'directory'})); + //=> '/Users/sindresorhus' +})(); +``` + +## API + +### findUp(name, options?) +### findUp(matcher, options?) + +Returns a `Promise` for either the path or `undefined` if it couldn't be found. + +### findUp([...name], options?) + +Returns a `Promise` for either the first path found (by respecting the order of the array) or `undefined` if none could be found. + +### findUp.sync(name, options?) +### findUp.sync(matcher, options?) + +Returns a path or `undefined` if it couldn't be found. + +### findUp.sync([...name], options?) + +Returns the first path found (by respecting the order of the array) or `undefined` if none could be found. + +#### name + +Type: `string` + +Name of the file or directory to find. + +#### matcher + +Type: `Function` + +A function that will be called with each directory until it returns a `string` with the path, which stops the search, or the root directory has been reached and nothing was found. Useful if you want to match files with certain patterns, set of permissions, or other advanced use-cases. + +When using async mode, the `matcher` may optionally be an async or promise-returning function that returns the path. + +#### options + +Type: `object` + +##### cwd + +Type: `string`\ +Default: `process.cwd()` + +Directory to start from. + +##### type + +Type: `string`\ +Default: `'file'`\ +Values: `'file'` `'directory'` + +The type of paths that can match. + +##### allowSymlinks + +Type: `boolean`\ +Default: `true` + +Allow symbolic links to match if they point to the chosen path type. + +### findUp.exists(path) + +Returns a `Promise` of whether the path exists. + +### findUp.sync.exists(path) + +Returns a `boolean` of whether the path exists. + +#### path + +Type: `string` + +Path to a file or directory. + +### findUp.stop + +A [`Symbol`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol) that can be returned by a `matcher` function to stop the search and cause `findUp` to immediately return `undefined`. Useful as a performance optimization in case the current working directory is deeply nested in the filesystem. + +```js +const path = require('path'); +const findUp = require('find-up'); + +(async () => { + await findUp(directory => { + return path.basename(directory) === 'work' ? findUp.stop : 'logo.png'; + }); +})(); +``` + +## Related + +- [find-up-cli](https://github.com/sindresorhus/find-up-cli) - CLI for this module +- [pkg-up](https://github.com/sindresorhus/pkg-up) - Find the closest package.json file +- [pkg-dir](https://github.com/sindresorhus/pkg-dir) - Find the root directory of an npm package +- [resolve-from](https://github.com/sindresorhus/resolve-from) - Resolve the path of a module like `require.resolve()` but from a given path + +--- + +
+ + Get professional support for 'find-up' with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
diff --git a/tools/ui/node_modules/flat-cache/LICENSE b/tools/ui/node_modules/flat-cache/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..7383a47e9c2c9d80083dae619d00f2de025d3135 --- /dev/null +++ b/tools/ui/node_modules/flat-cache/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) Roy Riojas and Jared Wray + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/tools/ui/node_modules/flat-cache/README.md b/tools/ui/node_modules/flat-cache/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3d7793aac1aca3f4026d031ec851cfd89e56fd93 --- /dev/null +++ b/tools/ui/node_modules/flat-cache/README.md @@ -0,0 +1,77 @@ +# flat-cache + +> A stupidly simple key/value storage using files to persist the data + +[![NPM Version](https://img.shields.io/npm/v/flat-cache.svg?style=flat)](https://npmjs.org/package/flat-cache) +[![tests](https://github.com/jaredwray/flat-cache/actions/workflows/tests.yaml/badge.svg?branch=master)](https://github.com/jaredwray/flat-cache/actions/workflows/tests.yaml) +[![codecov](https://codecov.io/github/jaredwray/flat-cache/branch/master/graph/badge.svg?token=KxR95XT3NF)](https://codecov.io/github/jaredwray/flat-cache) +[![npm](https://img.shields.io/npm/dm/flat-cache)](https://npmjs.com/package/flat-cache) + +## install + +```bash +npm i --save flat-cache +``` + +## Usage + +```js +const flatCache = require('flat-cache'); +// loads the cache, if one does not exists for the given +// Id a new one will be prepared to be created +const cache = flatCache.load('cacheId'); + +// sets a key on the cache +cache.setKey('key', { foo: 'var' }); + +// get a key from the cache +cache.getKey('key'); // { foo: 'var' } + +// fetch the entire persisted object +cache.all(); // { 'key': { foo: 'var' } } + +// remove a key +cache.removeKey('key'); // removes a key from the cache + +// save it to disk +cache.save(); // very important, if you don't save no changes will be persisted. +// cache.save( true /* noPrune */) // can be used to prevent the removal of non visited keys + +// loads the cache from a given directory, if one does +// not exists for the given Id a new one will be prepared to be created +const cache = flatCache.load('cacheId', path.resolve('./path/to/folder')); + +// The following methods are useful to clear the cache +// delete a given cache +flatCache.clearCacheById('cacheId'); // removes the cacheId document if one exists. + +// delete all cache +flatCache.clearAll(); // remove the cache directory +``` + +## Motivation for this module + +I needed a super simple and dumb **in-memory cache** with optional disk persistance in order to make +a script that will beutify files with `esformatter` only execute on the files that were changed since the last run. +To make that possible we need to store the `fileSize` and `modificationTime` of the files. So a simple `key/value` +storage was needed and Bam! this module was born. + +## Important notes + +- If no directory is especified when the `load` method is called, a folder named `.cache` will be created + inside the module directory when `cache.save` is called. If you're committing your `node_modules` to any vcs, you + might want to ignore the default `.cache` folder, or specify a custom directory. +- The values set on the keys of the cache should be `stringify-able` ones, meaning no circular references +- All the changes to the cache state are done to memory +- I could have used a timer or `Object.observe` to deliver the changes to disk, but I wanted to keep this module + intentionally dumb and simple +- Non visited keys are removed when `cache.save()` is called. If this is not desired, you can pass `true` to the save call + like: `cache.save( true /* noPrune */ )`. + +## License + +MIT + +## Changelog + +[changelog](./changelog.md) diff --git a/tools/ui/node_modules/flat-cache/changelog.md b/tools/ui/node_modules/flat-cache/changelog.md new file mode 100644 index 0000000000000000000000000000000000000000..866f9501d96b9320914016c85ce3bc1c57d4f11b --- /dev/null +++ b/tools/ui/node_modules/flat-cache/changelog.md @@ -0,0 +1,278 @@ +# flat-cache - Changelog + +## v3.0.4 + +- **Refactoring** + - add files by name to the list of exported files - [89a2698](https://github.com/royriojas/flat-cache/commit/89a2698), [Roy Riojas](https://github.com/Roy Riojas), 08/11/2020 02:35:39 + +## v3.0.3 + +- **Bug Fixes** + - Fix wrong eslint command - [f268e42](https://github.com/royriojas/flat-cache/commit/f268e42), [Roy Riojas](https://github.com/Roy Riojas), 08/11/2020 02:15:04 + +## v3.0.2 + +- **Refactoring** + + - Update the files paths - [6983a80](https://github.com/royriojas/flat-cache/commit/6983a80), [Roy Riojas](https://github.com/Roy Riojas), 08/11/2020 01:58:39 + - Move code to src/ - [18ed6e8](https://github.com/royriojas/flat-cache/commit/18ed6e8), [Roy Riojas](https://github.com/Roy Riojas), 08/11/2020 01:57:17 + - Change eslint-cache location - [beed74c](https://github.com/royriojas/flat-cache/commit/beed74c), [Roy Riojas](https://github.com/Roy Riojas), 08/11/2020 01:48:32 + +## v3.0.1 + +- **Refactoring** + - Remove unused deps - [8c6d9dc](https://github.com/royriojas/flat-cache/commit/8c6d9dc), [Roy Riojas](https://github.com/Roy Riojas), 08/11/2020 01:43:29 + +## v3.0.0 + +- **Refactoring** + - Fix engines - [52b824c](https://github.com/royriojas/flat-cache/commit/52b824c), [Roy Riojas](https://github.com/Roy Riojas), 08/11/2020 01:01:52 +- **Other changes** + + - Replace write with combination of mkdir and writeFile ([#49](https://github.com/royriojas/flat-cache/issues/49)) - [ef48276](https://github.com/royriojas/flat-cache/commit/ef48276), [Bogdan Chadkin](https://github.com/Bogdan Chadkin), 08/11/2020 00:17:15 + + Node v10 introduced a great "recursive" option for mkdir which allows to + get rid from mkdirp package and easily rewrite "write" package usage + with two function calls. + + https://nodejs.org/api/fs.html#fs_fs_mkdir_path_options_callback + + - Added a testcase for clearAll ([#48](https://github.com/royriojas/flat-cache/issues/48)) - [45b51ca](https://github.com/royriojas/flat-cache/commit/45b51ca), [Aaron Chen](https://github.com/Aaron Chen), 21/05/2020 08:40:03 + - requet node>=10 - [a5c482c](https://github.com/royriojas/flat-cache/commit/a5c482c), [yumetodo](https://github.com/yumetodo), 10/04/2020 23:14:53 + + thanks @SuperITMan + + - Update README.md - [29fe40b](https://github.com/royriojas/flat-cache/commit/29fe40b), [Roy Riojas](https://github.com/Roy Riojas), 10/04/2020 20:08:05 + - reduce vulnerability to 1 - [e9db1b2](https://github.com/royriojas/flat-cache/commit/e9db1b2), [yumetodo](https://github.com/yumetodo), 30/03/2020 11:10:43 + - reduce vulnerabilities dependencies to 8 - [b58d196](https://github.com/royriojas/flat-cache/commit/b58d196), [yumetodo](https://github.com/yumetodo), 30/03/2020 10:54:56 + - use prettier instead of esbeautifier - [03b1db7](https://github.com/royriojas/flat-cache/commit/03b1db7), [yumetodo](https://github.com/yumetodo), 30/03/2020 10:27:14 + - update proxyquire - [c2f048d](https://github.com/royriojas/flat-cache/commit/c2f048d), [yumetodo](https://github.com/yumetodo), 30/03/2020 10:16:16 + - update flatted and mocha - [a0e56da](https://github.com/royriojas/flat-cache/commit/a0e56da), [yumetodo](https://github.com/yumetodo), 30/03/2020 09:46:45 + + mocha > mkdirp is updated + istanble >>> optimist > minimist is not updated + + - drop support node.js < 10 in develop - [beba691](https://github.com/royriojas/flat-cache/commit/beba691), [yumetodo](https://github.com/yumetodo), 18/03/2020 01:31:09 + + see mkdirp + + - npm aufit fix(still remains) - [ce166cb](https://github.com/royriojas/flat-cache/commit/ce166cb), [yumetodo](https://github.com/yumetodo), 18/03/2020 01:18:08 + + 37 vulnerabilities required manual review and could not be updated + + - updtate sinon - [9f2d1b6](https://github.com/royriojas/flat-cache/commit/9f2d1b6), [yumetodo](https://github.com/yumetodo), 18/03/2020 01:17:51 + - apply eslint-plugin-mocha - [07343b5](https://github.com/royriojas/flat-cache/commit/07343b5), [yumetodo](https://github.com/yumetodo), 13/03/2020 22:17:21 + - Less strint version check ([#44](https://github.com/royriojas/flat-cache/issues/44)) - [92aca1c](https://github.com/royriojas/flat-cache/commit/92aca1c), [Wojciech Maj](https://github.com/Wojciech Maj), 13/11/2019 16:18:25 + + - Use ^ version matching for production dependencies + - Run npm audit fix + +- **Bug Fixes** + - update dependencies and use eslint directly - [73fbed2](https://github.com/royriojas/flat-cache/commit/73fbed2), [yumetodo](https://github.com/yumetodo), 18/03/2020 01:17:27 + +## v2.0.1 + +- **Refactoring** + - upgrade node modules to latest versions - [6402ed3](https://github.com/royriojas/flat-cache/commit/6402ed3), [Roy Riojas](https://github.com/Roy Riojas), 08/01/2019 18:47:05 + +## v2.0.0 + +- **Bug Fixes** + + - upgrade package.json lock file - [8d21c7b](https://github.com/royriojas/flat-cache/commit/8d21c7b), [Roy Riojas](https://github.com/Roy Riojas), 08/01/2019 17:03:13 + - Use the same versions of node_js that eslint use - [8d23379](https://github.com/royriojas/flat-cache/commit/8d23379), [Roy Riojas](https://github.com/Roy Riojas), 08/01/2019 16:25:11 + +- **Other changes** + + - Replace circular-json with flatted ([#36](https://github.com/royriojas/flat-cache/issues/36)) - [b93aced](https://github.com/royriojas/flat-cache/commit/b93aced), [C. K. Tang](https://github.com/C. K. Tang), 08/01/2019 17:03:01 + - Change JSON parser from circular-json to flatted & 1 more changes ([#37](https://github.com/royriojas/flat-cache/issues/37)) - [745e65a](https://github.com/royriojas/flat-cache/commit/745e65a), [Andy Chen](https://github.com/Andy Chen), 08/01/2019 16:17:20 + + - Change JSON parser from circular-json to flatted & 1 more changes + - Change JSON parser from circular-json + - Audited 2 vulnerabilities + - Update package.json + - Update Engine require + - There's a bunch of dependencies in this pkg requires node >=4, so I changed it to 4 + - Remove and add node versions + - I have seen this pkg is not available with node 0.12 so I removed it + - I have added a popular used LTS version of node - 10 + +## v1.3.4 + +- **Refactoring** + - Add del.js and utils.js to the list of files to be beautified - [9d0ca9b](https://github.com/royriojas/flat-cache/commit/9d0ca9b), [Roy Riojas](https://github.com/Roy Riojas), 14/11/2018 12:19:02 + +## v1.3.3 + +- **Refactoring** + - Make sure package-lock.json is up to date - [a7d2598](https://github.com/royriojas/flat-cache/commit/a7d2598), [Roy Riojas](https://github.com/Roy Riojas), 14/11/2018 11:36:08 +- **Other changes** + + - Removed the need for del ([#33](https://github.com/royriojas/flat-cache/issues/33)) - [c429012](https://github.com/royriojas/flat-cache/commit/c429012), [S. Gilroy](https://github.com/S. Gilroy), 13/11/2018 13:56:37 + + - Removed the need for del + + Removed the need for del as newer versions have broken backwards + compatibility. del mainly uses rimraf for deleting folders + and files, replaceing it with rimraf only is a minimal change. + + - Disable glob on rimraf calls + - Added glob disable to wrong call + - Wrapped rimraf to simplify solution + +## v1.3.2 + +- **Refactoring** + - remove yarn.lock file - [704c6c4](https://github.com/royriojas/flat-cache/commit/704c6c4), [Roy Riojas](https://github.com/Roy Riojas), 07/11/2018 15:41:08 +- **Other changes** + + - replace circular-json with flatted ([#23](https://github.com/royriojas/flat-cache/issues/23))" - [db12d74](https://github.com/royriojas/flat-cache/commit/db12d74), [Roy Riojas](https://github.com/Roy Riojas), 07/11/2018 15:40:39 + + This reverts commit 00f689277a75e85fef28e6a048fad227afc525e6. + +## v1.3.1 + +- **Refactoring** + - upgrade deps to remove some security warnings - [f405719](https://github.com/royriojas/flat-cache/commit/f405719), [Roy Riojas](https://github.com/Roy Riojas), 06/11/2018 12:07:31 +- **Bug Fixes** + - replace circular-json with flatted ([#23](https://github.com/royriojas/flat-cache/issues/23)) - [00f6892](https://github.com/royriojas/flat-cache/commit/00f6892), [Terry](https://github.com/Terry), 05/11/2018 18:44:16 +- **Other changes** + + - update del to v3.0.0 ([#26](https://github.com/royriojas/flat-cache/issues/26)) - [d42883f](https://github.com/royriojas/flat-cache/commit/d42883f), [Patrick Silva](https://github.com/Patrick Silva), 03/11/2018 01:00:44 + + Closes #25 + +## v1.3.0 + +- **Other changes** + + - Added #all method ([#16](https://github.com/royriojas/flat-cache/issues/16)) - [12293be](https://github.com/royriojas/flat-cache/commit/12293be), [Ozair Patel](https://github.com/Ozair Patel), 25/09/2017 14:46:38 + + - Added #all method + - Added #all method test + - Updated readme + - Added yarn.lock + - Added more keys for #all test + - Beautified file + + - fix changelog title style ([#14](https://github.com/royriojas/flat-cache/issues/14)) - [af8338a](https://github.com/royriojas/flat-cache/commit/af8338a), [前端小武](https://github.com/前端小武), 19/12/2016 20:34:48 + +## v1.2.2 + +- **Bug Fixes** + + - Do not crash if cache file is invalid JSON. ([#13](https://github.com/royriojas/flat-cache/issues/13)) - [87beaa6](https://github.com/royriojas/flat-cache/commit/87beaa6), [Roy Riojas](https://github.com/Roy Riojas), 19/12/2016 18:03:35 + + Fixes #12 + + Not sure under which situations a cache file might exist that does + not contain a valid JSON structure, but just in case to cover + the possibility of this happening a try catch block has been added + + If the cache is somehow not valid the cache will be discarded an a + a new cache will be stored instead + +- **Other changes** + + - Added travis ci support for modern node versions ([#11](https://github.com/royriojas/flat-cache/issues/11)) - [1c2b1f7](https://github.com/royriojas/flat-cache/commit/1c2b1f7), [Amila Welihinda](https://github.com/Amila Welihinda), 10/11/2016 23:47:52 + - Bumping `circular-son` version ([#10](https://github.com/royriojas/flat-cache/issues/10)) - [4d5e861](https://github.com/royriojas/flat-cache/commit/4d5e861), [Andrea Giammarchi](https://github.com/Andrea Giammarchi), 02/08/2016 07:13:52 + + As mentioned in https://github.com/WebReflection/circular-json/issues/25 `circular-json` wan't rightly implementing the license field. + + Latest version bump changed only that bit so that ESLint should now be happy. + +## v1.2.1 + +- **Bug Fixes** + - Add missing utils.js file to the package. closes [#8](https://github.com/royriojas/flat-cache/issues/8) - [ec10cf2](https://github.com/royriojas/flat-cache/commit/ec10cf2), [Roy Riojas](https://github.com/Roy Riojas), 01/08/2016 02:18:57 + +## v1.2.0 + +- **Documentation** + - Add documentation about noPrune option - [23e11f9](https://github.com/royriojas/flat-cache/commit/23e11f9), [Roy Riojas](https://github.com/Roy Riojas), 01/08/2016 02:06:49 + +## v1.0.11 + +- **Features** + + - Add noPrune option to cache.save() method. closes [#7](https://github.com/royriojas/flat-cache/issues/7) - [2c8016a](https://github.com/royriojas/flat-cache/commit/2c8016a), [Roy Riojas](https://github.com/Roy Riojas), 01/08/2016 02:00:29 + - Add json read and write utility based on circular-json - [c31081e](https://github.com/royriojas/flat-cache/commit/c31081e), [Jean Ponchon](https://github.com/Jean Ponchon), 28/07/2016 08:58:17 + +- **Bug Fixes** + + - Remove UTF16 BOM stripping - [4a41e22](https://github.com/royriojas/flat-cache/commit/4a41e22), [Jean Ponchon](https://github.com/Jean Ponchon), 29/07/2016 02:18:06 + + Since we control both writing and reading of JSON stream, there no needs + to handle unicode BOM. + + - Use circular-json to handle circular references (fix [#5](https://github.com/royriojas/flat-cache/issues/5)) - [cd7aeed](https://github.com/royriojas/flat-cache/commit/cd7aeed), [Jean Ponchon](https://github.com/Jean Ponchon), 25/07/2016 11:11:59 + +- **Tests Related fixes** + + - Add missing file from eslint test - [d6fa3c3](https://github.com/royriojas/flat-cache/commit/d6fa3c3), [Jean Ponchon](https://github.com/Jean Ponchon), 29/07/2016 02:15:51 + - Add test for circular json serialization / deserialization - [07d2ddd](https://github.com/royriojas/flat-cache/commit/07d2ddd), [Jean Ponchon](https://github.com/Jean Ponchon), 28/07/2016 08:59:36 + +- **Refactoring** + - Remove unused read-json-sync - [2be1c24](https://github.com/royriojas/flat-cache/commit/2be1c24), [Jean Ponchon](https://github.com/Jean Ponchon), 28/07/2016 08:59:18 +- **Build Scripts Changes** + - travis tests on 0.12 and 4x - [3a613fd](https://github.com/royriojas/flat-cache/commit/3a613fd), [royriojas](https://github.com/royriojas), 15/11/2015 14:34:40 + +## v1.0.10 + +- **Build Scripts Changes** + + - add eslint-fix task - [fd29e52](https://github.com/royriojas/flat-cache/commit/fd29e52), [royriojas](https://github.com/royriojas), 01/11/2015 15:04:08 + - make sure the test script also verify beautification and linting of files before running tests - [e94e176](https://github.com/royriojas/flat-cache/commit/e94e176), [royriojas](https://github.com/royriojas), 01/11/2015 11:54:48 + +- **Other changes** + - add clearAll for cacheDir - [97383d9](https://github.com/royriojas/flat-cache/commit/97383d9), [xieyaowu](https://github.com/xieyaowu), 31/10/2015 21:02:18 + +## v1.0.9 + +- **Bug Fixes** + - wrong default values for changelogx user repo name - [7bb52d1](https://github.com/royriojas/flat-cache/commit/7bb52d1), [royriojas](https://github.com/royriojas), 11/09/2015 15:59:30 + +## v1.0.8 + +- **Build Scripts Changes** + - test against node 4 - [c395b66](https://github.com/royriojas/flat-cache/commit/c395b66), [royriojas](https://github.com/royriojas), 11/09/2015 15:51:39 + +## v1.0.7 + +- **Other changes** + - Move dependencies into devDep - [7e47099](https://github.com/royriojas/flat-cache/commit/7e47099), [Bogdan Chadkin](https://github.com/Bogdan Chadkin), 11/09/2015 15:10:57 +- **Documentation** + - Add missing changelog link - [f51197a](https://github.com/royriojas/flat-cache/commit/f51197a), [royriojas](https://github.com/royriojas), 11/09/2015 14:48:05 + +## v1.0.6 + +- **Build Scripts Changes** + - Add helpers/code check scripts - [bdb82f3](https://github.com/royriojas/flat-cache/commit/bdb82f3), [royriojas](https://github.com/royriojas), 11/09/2015 14:44:31 + +## v1.0.5 + +- **Documentation** + - better description for the module - [436817f](https://github.com/royriojas/flat-cache/commit/436817f), [royriojas](https://github.com/royriojas), 11/09/2015 14:35:33 +- **Other changes** + - Update dependencies - [be88aa3](https://github.com/royriojas/flat-cache/commit/be88aa3), [Bogdan Chadkin](https://github.com/Bogdan Chadkin), 11/09/2015 13:47:41 + +## v1.0.4 + +- **Refactoring** + - load a cache file using the full filepath - [b8f68c2](https://github.com/royriojas/flat-cache/commit/b8f68c2), [Roy Riojas](https://github.com/Roy Riojas), 30/08/2015 04:19:14 +- **Documentation** + - Add documentation about `clearAll` and `clearCacheById` - [13947c1](https://github.com/royriojas/flat-cache/commit/13947c1), [Roy Riojas](https://github.com/Roy Riojas), 01/03/2015 23:44:05 +- **Features** + - Add methods to remove the cache documents created - [af40443](https://github.com/royriojas/flat-cache/commit/af40443), [Roy Riojas](https://github.com/Roy Riojas), 01/03/2015 23:39:27 + +## v1.0.1 + +- **Other changes** + - Update README.md - [c2b6805](https://github.com/royriojas/flat-cache/commit/c2b6805), [Roy Riojas](https://github.com/Roy Riojas), 26/02/2015 04:28:07 + +## v1.0.0 + +- **Refactoring** + - flat-cache v.1.0.0 - [c984274](https://github.com/royriojas/flat-cache/commit/c984274), [Roy Riojas](https://github.com/Roy Riojas), 26/02/2015 04:11:50 +- **Other changes** + - Initial commit - [d43cccf](https://github.com/royriojas/flat-cache/commit/d43cccf), [Roy Riojas](https://github.com/Roy Riojas), 26/02/2015 01:12:16 diff --git a/tools/ui/node_modules/flat-cache/package.json b/tools/ui/node_modules/flat-cache/package.json new file mode 100644 index 0000000000000000000000000000000000000000..b1248837543472d0048b3eb98e07647912ee62ec --- /dev/null +++ b/tools/ui/node_modules/flat-cache/package.json @@ -0,0 +1,63 @@ +{ + "name": "flat-cache", + "version": "4.0.1", + "description": "A stupidly simple key/value storage using files to persist some data", + "repository": "jaredwray/flat-cache", + "license": "MIT", + "author": { + "name": "Jared Wray", + "url": "https://jaredwray.com" + }, + "main": "src/cache.js", + "files": [ + "src/cache.js", + "src/del.js", + "src/utils.js" + ], + "engines": { + "node": ">=16" + }, + "precommit": [ + "npm run verify --silent" + ], + "prepush": [ + "npm run verify --silent" + ], + "scripts": { + "eslint": "eslint --cache --cache-location=node_modules/.cache/ ./src/**/*.js ./test/**/*.js", + "clean": "rimraf ./node_modules ./package-lock.json ./yarn.lock ./coverage", + "eslint-fix": "npm run eslint -- --fix", + "autofix": "npm run eslint-fix", + "check": "npm run eslint", + "verify": "npm run eslint && npm run test:cache", + "test:cache": "c8 mocha -R spec test/specs", + "test:ci:cache": "c8 --reporter=lcov mocha -R spec test/specs", + "test": "npm run verify --silent", + "format": "prettier --write ." + }, + "keywords": [ + "json cache", + "simple cache", + "file cache", + "key par", + "key value", + "cache" + ], + "devDependencies": { + "c8": "^9.1.0", + "chai": "^4.3.10", + "eslint": "^8.56.0", + "eslint-config-prettier": "^9.1.0", + "eslint-plugin-mocha": "^10.2.0", + "glob-expand": "^0.2.1", + "mocha": "^10.3.0", + "prettier": "^3.2.4", + "rimraf": "^5.0.5", + "sinon": "^17.0.1", + "write": "^2.0.0" + }, + "dependencies": { + "flatted": "^3.2.9", + "keyv": "^4.5.4" + } +} diff --git a/tools/ui/node_modules/flat-cache/src/cache.js b/tools/ui/node_modules/flat-cache/src/cache.js new file mode 100644 index 0000000000000000000000000000000000000000..b1fdf6d88c1ebd338ff2519755fa4863915166b6 --- /dev/null +++ b/tools/ui/node_modules/flat-cache/src/cache.js @@ -0,0 +1,214 @@ +const path = require('path'); +const fs = require('fs'); +const Keyv = require('keyv'); +const { writeJSON, tryParse } = require('./utils'); +const { del } = require('./del'); + +const cache = { + /** + * Load a cache identified by the given Id. If the element does not exists, then initialize an empty + * cache storage. If specified `cacheDir` will be used as the directory to persist the data to. If omitted + * then the cache module directory `./cache` will be used instead + * + * @method load + * @param docId {String} the id of the cache, would also be used as the name of the file cache + * @param [cacheDir] {String} directory for the cache entry + */ + load: function (docId, cacheDir) { + const me = this; + me.keyv = new Keyv(); + + me.__visited = {}; + me.__persisted = {}; + + me._pathToFile = cacheDir ? path.resolve(cacheDir, docId) : path.resolve(__dirname, '../.cache/', docId); + + if (fs.existsSync(me._pathToFile)) { + me._persisted = tryParse(me._pathToFile, {}); + } + }, + + get _persisted() { + return this.__persisted; + }, + + set _persisted(value) { + this.__persisted = value; + }, + + get _visited() { + return this.__visited; + }, + + set _visited(value) { + this.__visited = value; + }, + + /** + * Load the cache from the provided file + * @method loadFile + * @param {String} pathToFile the path to the file containing the info for the cache + */ + loadFile: function (pathToFile) { + const me = this; + const dir = path.dirname(pathToFile); + const fName = path.basename(pathToFile); + + me.load(fName, dir); + }, + + /** + * Returns the entire persisted object + * @method all + * @returns {*} + */ + all: function () { + return this._persisted; + }, + + keys: function () { + return Object.keys(this._persisted); + }, + /** + * sets a key to a given value + * @method setKey + * @param key {string} the key to set + * @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify + */ + setKey: function (key, value) { + this._visited[key] = true; + this._persisted[key] = value; + }, + /** + * remove a given key from the cache + * @method removeKey + * @param key {String} the key to remove from the object + */ + removeKey: function (key) { + delete this._visited[key]; // esfmt-ignore-line + delete this._persisted[key]; // esfmt-ignore-line + }, + /** + * Return the value of the provided key + * @method getKey + * @param key {String} the name of the key to retrieve + * @returns {*} the value from the key + */ + getKey: function (key) { + this._visited[key] = true; + return this._persisted[key]; + }, + + /** + * Remove keys that were not accessed/set since the + * last time the `prune` method was called. + * @method _prune + * @private + */ + _prune: function () { + const me = this; + const obj = {}; + + const keys = Object.keys(me._visited); + + // no keys visited for either get or set value + if (keys.length === 0) { + return; + } + + keys.forEach(function (key) { + obj[key] = me._persisted[key]; + }); + + me._visited = {}; + me._persisted = obj; + }, + + /** + * Save the state of the cache identified by the docId to disk + * as a JSON structure + * @param [noPrune=false] {Boolean} whether to remove from cache the non visited files + * @method save + */ + save: function (noPrune) { + const me = this; + !noPrune && me._prune(); + writeJSON(me._pathToFile, me._persisted); + }, + + /** + * remove the file where the cache is persisted + * @method removeCacheFile + * @return {Boolean} true or false if the file was successfully deleted + */ + removeCacheFile: function () { + return del(this._pathToFile); + }, + /** + * Destroy the file cache and cache content. + * @method destroy + */ + destroy: function () { + const me = this; + me._visited = {}; + me._persisted = {}; + + me.removeCacheFile(); + }, +}; + +module.exports = { + /** + * Alias for create. Should be considered depreacted. Will be removed in next releases + * + * @method load + * @param docId {String} the id of the cache, would also be used as the name of the file cache + * @param [cacheDir] {String} directory for the cache entry + * @returns {cache} cache instance + */ + load: function (docId, cacheDir) { + return this.create(docId, cacheDir); + }, + + /** + * Load a cache identified by the given Id. If the element does not exists, then initialize an empty + * cache storage. + * + * @method create + * @param docId {String} the id of the cache, would also be used as the name of the file cache + * @param [cacheDir] {String} directory for the cache entry + * @returns {cache} cache instance + */ + create: function (docId, cacheDir) { + const obj = Object.create(cache); + obj.load(docId, cacheDir); + return obj; + }, + + createFromFile: function (filePath) { + const obj = Object.create(cache); + obj.loadFile(filePath); + return obj; + }, + /** + * Clear the cache identified by the given id. Caches stored in a different cache directory can be deleted directly + * + * @method clearCache + * @param docId {String} the id of the cache, would also be used as the name of the file cache + * @param cacheDir {String} the directory where the cache file was written + * @returns {Boolean} true if the cache folder was deleted. False otherwise + */ + clearCacheById: function (docId, cacheDir) { + const filePath = cacheDir ? path.resolve(cacheDir, docId) : path.resolve(__dirname, '../.cache/', docId); + return del(filePath); + }, + /** + * Remove all cache stored in the cache directory + * @method clearAll + * @returns {Boolean} true if the cache folder was deleted. False otherwise + */ + clearAll: function (cacheDir) { + const filePath = cacheDir ? path.resolve(cacheDir) : path.resolve(__dirname, '../.cache/'); + return del(filePath); + }, +}; diff --git a/tools/ui/node_modules/flat-cache/src/del.js b/tools/ui/node_modules/flat-cache/src/del.js new file mode 100644 index 0000000000000000000000000000000000000000..9cd55c369a0a4bd1bf0d177ca972cfc6faacfb49 --- /dev/null +++ b/tools/ui/node_modules/flat-cache/src/del.js @@ -0,0 +1,30 @@ +const fs = require('fs'); +const path = require('path'); + +function del(targetPath) { + if (!fs.existsSync(targetPath)) { + return false; + } + + try { + if (fs.statSync(targetPath).isDirectory()) { + // If it's a directory, delete its contents first + fs.readdirSync(targetPath).forEach(file => { + const curPath = path.join(targetPath, file); + + if (fs.statSync(curPath).isFile()) { + fs.unlinkSync(curPath); // Delete file + } + }); + fs.rmdirSync(targetPath); // Delete the now-empty directory + } else { + fs.unlinkSync(targetPath); // If it's a file, delete it directly + } + + return true; + } catch (error) { + console.error(`Error while deleting ${targetPath}: ${error.message}`); + } +} + +module.exports = { del }; diff --git a/tools/ui/node_modules/flat-cache/src/utils.js b/tools/ui/node_modules/flat-cache/src/utils.js new file mode 100644 index 0000000000000000000000000000000000000000..c4f75fbc8bcf1704bc5bb608fd7e4782bf12550f --- /dev/null +++ b/tools/ui/node_modules/flat-cache/src/utils.js @@ -0,0 +1,42 @@ +const fs = require('fs'); +const path = require('path'); +const flatted = require('flatted'); + +function tryParse(filePath, defaultValue) { + let result; + try { + result = readJSON(filePath); + } catch (ex) { + result = defaultValue; + } + return result; +} + +/** + * Read json file synchronously using flatted + * + * @param {String} filePath Json filepath + * @returns {*} parse result + */ +function readJSON(filePath) { + return flatted.parse( + fs.readFileSync(filePath, { + encoding: 'utf8', + }) + ); +} + +/** + * Write json file synchronously using circular-json + * + * @param {String} filePath Json filepath + * @param {*} data Object to serialize + */ +function writeJSON(filePath, data) { + fs.mkdirSync(path.dirname(filePath), { + recursive: true, + }); + fs.writeFileSync(filePath, flatted.stringify(data)); +} + +module.exports = { tryParse, readJSON, writeJSON }; diff --git a/tools/ui/node_modules/flatted/LICENSE b/tools/ui/node_modules/flatted/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..506dc479c6b3482ff184ed1f32f284bfbcc47db8 --- /dev/null +++ b/tools/ui/node_modules/flatted/LICENSE @@ -0,0 +1,15 @@ +ISC License + +Copyright (c) 2018-2020, Andrea Giammarchi, @WebReflection + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. diff --git a/tools/ui/node_modules/flatted/README.md b/tools/ui/node_modules/flatted/README.md new file mode 100644 index 0000000000000000000000000000000000000000..429c15244b05f949a6214ce229c74a7df9ab6f4d --- /dev/null +++ b/tools/ui/node_modules/flatted/README.md @@ -0,0 +1,111 @@ +# flatted + +[![Downloads](https://img.shields.io/npm/dm/flatted.svg)](https://www.npmjs.com/package/flatted) [![Coverage Status](https://coveralls.io/repos/github/WebReflection/flatted/badge.svg?branch=main)](https://coveralls.io/github/WebReflection/flatted?branch=main) [![License: ISC](https://img.shields.io/badge/License-ISC-yellow.svg)](https://opensource.org/licenses/ISC) ![WebReflection status](https://offline.report/status/webreflection.svg) + +![snow flake](./flatted.jpg) + +**Social Media Photo by [Matt Seymour](https://unsplash.com/@mattseymour) on [Unsplash](https://unsplash.com/)** + +A super light (0.5K) and fast circular JSON parser, directly from the creator of [CircularJSON](https://github.com/WebReflection/circular-json/#circularjson). + +Available also for **[PHP](./php/flatted.php)**. + +Available also for **[Python](./python/flatted.py)**. + +Available also for **[Go](./golang/README.md)**. + +- - - + +## ℹ️ JSON only values + +If you need anything more complex than values JSON understands, there is a standard approach to recursion and more data-types than what JSON allows, and it's part of the [Structured Clone polyfill](https://github.com/ungap/structured-clone/#readme). + +- - - + +```js +npm i flatted +``` + +Usable via [CDN](https://unpkg.com/flatted) or as regular module. + +```js +// ESM +import {parse, stringify, toJSON, fromJSON} from 'flatted'; + +// CJS +const {parse, stringify, toJSON, fromJSON} = require('flatted'); + +const a = [{}]; +a[0].a = a; +a.push(a); + +stringify(a); // [["1","0"],{"a":"0"}] +``` + +## toJSON and fromJSON + +If you'd like to implicitly survive JSON serialization, these two helpers helps: + +```js +import {toJSON, fromJSON} from 'flatted'; + +class RecursiveMap extends Map { + static fromJSON(any) { + return new this(fromJSON(any)); + } + toJSON() { + return toJSON([...this.entries()]); + } +} + +const recursive = new RecursiveMap; +const same = {}; +same.same = same; +recursive.set('same', same); + +const asString = JSON.stringify(recursive); +const asMap = RecursiveMap.fromJSON(JSON.parse(asString)); +asMap.get('same') === asMap.get('same').same; +// true +``` + + +## Flatted VS JSON + +As it is for every other specialized format capable of serializing and deserializing circular data, you should never `JSON.parse(Flatted.stringify(data))`, and you should never `Flatted.parse(JSON.stringify(data))`. + +The only way this could work is to `Flatted.parse(Flatted.stringify(data))`, as it is also for _CircularJSON_ or any other, otherwise there's no granted data integrity. + +Also please note this project serializes and deserializes only data compatible with JSON, so that sockets, or anything else with internal classes different from those allowed by JSON standard, won't be serialized and unserialized as expected. + + +### New in V1: Exact same JSON API + + * Added a [reviver](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse#Syntax) parameter to `.parse(string, reviver)` and revive your own objects. + * Added a [replacer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#Syntax) and a `space` parameter to `.stringify(object, replacer, space)` for feature parity with JSON signature. + + +### Compatibility +All ECMAScript engines compatible with `Map`, `Set`, `Object.keys`, and `Array.prototype.reduce` will work, even if polyfilled. + + +### How does it work ? +While stringifying, all Objects, including Arrays, and strings, are flattened out and replaced as unique index. `*` + +Once parsed, all indexes will be replaced through the flattened collection. + +`*` represented as string to avoid conflicts with numbers + +```js +// logic example +var a = [{one: 1}, {two: '2'}]; +a[0].a = a; +// a is the main object, will be at index '0' +// {one: 1} is the second object, index '1' +// {two: '2'} the third, in '2', and it has a string +// which will be found at index '3' + +Flatted.stringify(a); +// [["1","2"],{"one":1,"a":"0"},{"two":"3"},"2"] +// a[one,two] {one: 1, a} {two: '2'} '2' +``` diff --git a/tools/ui/node_modules/flatted/cjs/index.js b/tools/ui/node_modules/flatted/cjs/index.js new file mode 100644 index 0000000000000000000000000000000000000000..a4833a5b44a6e826abbb0e83db7c17f28d7e0711 --- /dev/null +++ b/tools/ui/node_modules/flatted/cjs/index.js @@ -0,0 +1,132 @@ +'use strict'; +/// + +// (c) 2020-present Andrea Giammarchi + +const {parse: $parse, stringify: $stringify} = JSON; +const {keys} = Object; + +const Primitive = String; // it could be Number +const primitive = 'string'; // it could be 'number' + +const ignore = {}; +const object = 'object'; + +const noop = (_, value) => value; + +const primitives = value => ( + value instanceof Primitive ? Primitive(value) : value +); + +const Primitives = (_, value) => ( + typeof value === primitive ? new Primitive(value) : value +); + +const resolver = (input, lazy, parsed, $) => output => { + for (let ke = keys(output), {length} = ke, y = 0; y < length; y++) { + const k = ke[y]; + const value = output[k]; + if (value instanceof Primitive) { + const tmp = input[+value]; + if (typeof tmp === object && !parsed.has(tmp)) { + parsed.add(tmp); + output[k] = ignore; + lazy.push({ o: output, k, r: tmp }); + } + else + output[k] = $.call(output, k, tmp); + } + else if (output[k] !== ignore) + output[k] = $.call(output, k, value); + } + return output; +}; + +const set = (known, input, value) => { + const index = Primitive(input.push(value) - 1); + known.set(value, index); + return index; +}; + +/** + * Converts a specialized flatted string into a JS value. + * @param {string} text + * @param {(this: any, key: string, value: any) => any} [reviver] + * @returns {any} + */ +const parse = (text, reviver) => { + const input = $parse(text, Primitives).map(primitives); + const $ = reviver || noop; + + let value = input[0]; + + if (typeof value === object && value) { + const lazy = []; + const revive = resolver(input, lazy, new Set, $); + value = revive(value); + + let i = 0; + while (i < lazy.length) { + // it could be a lazy.shift() but that's costly + const {o, k, r} = lazy[i++]; + o[k] = $.call(o, k, revive(r)); + } + } + + return $.call({'': value}, '', value); +}; +exports.parse = parse; + +/** + * Converts a JS value into a specialized flatted string. + * @param {any} value + * @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer] + * @param {string | number | undefined} [space] + * @returns {string} + */ +const stringify = (value, replacer, space) => { + const $ = replacer && typeof replacer === object ? + (k, v) => (k === '' || -1 < replacer.indexOf(k) ? v : void 0) : + (replacer || noop); + const known = new Map; + const input = []; + const output = []; + let i = +set(known, input, $.call({'': value}, '', value)); + let firstRun = !i; + while (i < input.length) { + firstRun = true; + output[i] = $stringify(input[i++], replace, space); + } + return '[' + output.join(',') + ']'; + function replace(key, value) { + if (firstRun) { + firstRun = !firstRun; + return value; + } + const after = $.call(this, key, value); + switch (typeof after) { + case object: + if (after === null) return after; + case primitive: + return known.get(after) || set(known, input, after); + } + return after; + } +}; +exports.stringify = stringify; + +/** + * Converts a generic value into a JSON serializable object without losing recursion. + * @param {any} value + * @returns {any} + */ +const toJSON = value => $parse(stringify(value)); +exports.toJSON = toJSON; + +/** + * Converts a previously serialized object with recursion into a recursive one. + * @param {any} value + * @returns {any} + */ +const fromJSON = value => parse($stringify(value)); +exports.fromJSON = fromJSON; diff --git a/tools/ui/node_modules/flatted/cjs/package.json b/tools/ui/node_modules/flatted/cjs/package.json new file mode 100644 index 0000000000000000000000000000000000000000..0292b9956f2e40d6eb3d0f3998e710d973113aaa --- /dev/null +++ b/tools/ui/node_modules/flatted/cjs/package.json @@ -0,0 +1 @@ +{"type":"commonjs"} \ No newline at end of file diff --git a/tools/ui/node_modules/flatted/es.js b/tools/ui/node_modules/flatted/es.js new file mode 100644 index 0000000000000000000000000000000000000000..3e4d1877aad1edf8d805f77e9c425556fae55318 --- /dev/null +++ b/tools/ui/node_modules/flatted/es.js @@ -0,0 +1 @@ +self.Flatted=function(t){"use strict";const{parse:e,stringify:n}=JSON,{keys:r}=Object,o=String,s="string",c={},l="object",f=(t,e)=>e,i=t=>t instanceof o?o(t):t,a=(t,e)=>typeof e===s?new o(e):e,u=(t,e,n)=>{const r=o(e.push(n)-1);return t.set(n,r),r},p=(t,n)=>{const s=e(t,a).map(i),u=n||f;let p=s[0];if(typeof p===l&&p){const t=[],e=((t,e,n,s)=>f=>{for(let i=r(f),{length:a}=i,u=0;u{const o=e&&typeof e===l?(t,n)=>""===t||-1p(n(t)),t.parse=p,t.stringify=g,t.toJSON=t=>e(g(t)),t}({}); diff --git a/tools/ui/node_modules/flatted/esm.js b/tools/ui/node_modules/flatted/esm.js new file mode 100644 index 0000000000000000000000000000000000000000..2563a4125c7ff76aff89c4ab92195d336066973f --- /dev/null +++ b/tools/ui/node_modules/flatted/esm.js @@ -0,0 +1 @@ +const{parse:t,stringify:e}=JSON,{keys:n}=Object,o=String,r="string",s={},c="object",l=(t,e)=>e,f=t=>t instanceof o?o(t):t,i=(t,e)=>typeof e===r?new o(e):e,a=(t,e,n)=>{const r=o(e.push(n)-1);return t.set(n,r),r},u=(e,r)=>{const a=t(e,i).map(f),u=r||l;let p=a[0];if(typeof p===c&&p){const t=[],e=((t,e,r,l)=>f=>{for(let i=n(f),{length:a}=i,u=0;u{const s=n&&typeof n===c?(t,e)=>""===t||-1t(p(e)),g=t=>u(e(t));export{g as fromJSON,u as parse,p as stringify,h as toJSON}; diff --git a/tools/ui/node_modules/flatted/esm/index.js b/tools/ui/node_modules/flatted/esm/index.js new file mode 100644 index 0000000000000000000000000000000000000000..eb2da2d3faa14c5efa8ee865d939f2c2b02f795d --- /dev/null +++ b/tools/ui/node_modules/flatted/esm/index.js @@ -0,0 +1,127 @@ +/// + +// (c) 2020-present Andrea Giammarchi + +const {parse: $parse, stringify: $stringify} = JSON; +const {keys} = Object; + +const Primitive = String; // it could be Number +const primitive = 'string'; // it could be 'number' + +const ignore = {}; +const object = 'object'; + +const noop = (_, value) => value; + +const primitives = value => ( + value instanceof Primitive ? Primitive(value) : value +); + +const Primitives = (_, value) => ( + typeof value === primitive ? new Primitive(value) : value +); + +const resolver = (input, lazy, parsed, $) => output => { + for (let ke = keys(output), {length} = ke, y = 0; y < length; y++) { + const k = ke[y]; + const value = output[k]; + if (value instanceof Primitive) { + const tmp = input[+value]; + if (typeof tmp === object && !parsed.has(tmp)) { + parsed.add(tmp); + output[k] = ignore; + lazy.push({ o: output, k, r: tmp }); + } + else + output[k] = $.call(output, k, tmp); + } + else if (output[k] !== ignore) + output[k] = $.call(output, k, value); + } + return output; +}; + +const set = (known, input, value) => { + const index = Primitive(input.push(value) - 1); + known.set(value, index); + return index; +}; + +/** + * Converts a specialized flatted string into a JS value. + * @param {string} text + * @param {(this: any, key: string, value: any) => any} [reviver] + * @returns {any} + */ +export const parse = (text, reviver) => { + const input = $parse(text, Primitives).map(primitives); + const $ = reviver || noop; + + let value = input[0]; + + if (typeof value === object && value) { + const lazy = []; + const revive = resolver(input, lazy, new Set, $); + value = revive(value); + + let i = 0; + while (i < lazy.length) { + // it could be a lazy.shift() but that's costly + const {o, k, r} = lazy[i++]; + o[k] = $.call(o, k, revive(r)); + } + } + + return $.call({'': value}, '', value); +}; + +/** + * Converts a JS value into a specialized flatted string. + * @param {any} value + * @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer] + * @param {string | number | undefined} [space] + * @returns {string} + */ +export const stringify = (value, replacer, space) => { + const $ = replacer && typeof replacer === object ? + (k, v) => (k === '' || -1 < replacer.indexOf(k) ? v : void 0) : + (replacer || noop); + const known = new Map; + const input = []; + const output = []; + let i = +set(known, input, $.call({'': value}, '', value)); + let firstRun = !i; + while (i < input.length) { + firstRun = true; + output[i] = $stringify(input[i++], replace, space); + } + return '[' + output.join(',') + ']'; + function replace(key, value) { + if (firstRun) { + firstRun = !firstRun; + return value; + } + const after = $.call(this, key, value); + switch (typeof after) { + case object: + if (after === null) return after; + case primitive: + return known.get(after) || set(known, input, after); + } + return after; + } +}; + +/** + * Converts a generic value into a JSON serializable object without losing recursion. + * @param {any} value + * @returns {any} + */ +export const toJSON = value => $parse(stringify(value)); + +/** + * Converts a previously serialized object with recursion into a recursive one. + * @param {any} value + * @returns {any} + */ +export const fromJSON = value => parse($stringify(value)); diff --git a/tools/ui/node_modules/flatted/golang/README.md b/tools/ui/node_modules/flatted/golang/README.md new file mode 100644 index 0000000000000000000000000000000000000000..1db041bf789a8b13c2d9fd484d92df1ae7036973 --- /dev/null +++ b/tools/ui/node_modules/flatted/golang/README.md @@ -0,0 +1,60 @@ +# flatted (Go) + +A super light and fast circular JSON parser. + +## Usage + +```go +package main + +import ( + "fmt" + "github.com/WebReflection/flatted/golang/pkg/flatted" +) + +type Group struct { + Name string `json:"name"` +} + +type User struct { + Name string `json:"name"` + Friend *User `json:"friend"` + Group *Group `json:"group"` +} + +func main() { + group := &Group{Name: "Developers"} + alice := &User{Name: "Alice", Group: group} + bob := &User{Name: "Bob", Group: group} + + alice.Friend = bob + bob.Friend = alice // Circular reference + + // Stringify Alice + s, _ := flatted.Stringify(alice) + fmt.Println(s) + // Output: [{"name":"Alice","friend":"1","group":"2"},{"name":"Bob","friend":"0","group":"2"},{"name":"Developers"}] + + // Flattening in action: + // Index "0" is Alice, Index "1" is Bob, Index "2" is the shared Group. + + // Parse back into a generic map structure + res, _ := flatted.Parse(s) + aliceMap := res.(map[string]any) + fmt.Println(aliceMap["name"]) // Alice +} +``` + +## CLI + +Build the binary using the provided Makefile: + +```bash +make build +``` + +Then use it to parse flatted JSON from stdin: + +```bash +echo '[{"a":"1"},"b"]' | ./flatted +``` diff --git a/tools/ui/node_modules/flatted/golang/pkg/flatted/flatted.go b/tools/ui/node_modules/flatted/golang/pkg/flatted/flatted.go new file mode 100644 index 0000000000000000000000000000000000000000..8e3922c0926a84ee0fcdbe55ff6518ed500daa11 --- /dev/null +++ b/tools/ui/node_modules/flatted/golang/pkg/flatted/flatted.go @@ -0,0 +1,277 @@ +package flatted + +import ( + "encoding/json" + "reflect" + "sort" + "strconv" + "strings" +) + +// flattedIndex is a internal type used to distinguish between +// actual strings and flatted indices during the reconstruction phase. +type flattedIndex string + +// Stringify converts a Go value into a specialized flatted JSON string. +func Stringify(value any, replacer any, space any) (string, error) { + knownKeys := []any{} + knownValues := []string{} + input := []any{} + + index := func(v any) string { + input = append(input, v) + idx := strconv.Itoa(len(input) - 1) + knownKeys = append(knownKeys, v) + knownValues = append(knownValues, idx) + return idx + } + + relate := func(v any) any { + if v == nil { + return nil + } + rv := reflect.ValueOf(v) + kind := rv.Kind() + if kind == reflect.String || kind == reflect.Slice || kind == reflect.Map || kind == reflect.Ptr { + for i, k := range knownKeys { + if kind == reflect.String { + if k == v { + return knownValues[i] + } + } else { + rk := reflect.ValueOf(k) + if rk.Kind() == kind && rk.Pointer() == rv.Pointer() { + return knownValues[i] + } + } + } + return index(v) + } + return v + } + + transform := func(v any) any { + rv := reflect.ValueOf(v) + if !rv.IsValid() { + return nil + } + if _, ok := v.(json.Marshaler); ok { + return v + } + // Dereference pointers to process the underlying Slice, Map, or Array + for rv.Kind() == reflect.Ptr && !rv.IsNil() { + rv = rv.Elem() + } + switch rv.Kind() { + case reflect.Slice, reflect.Array: + res := make([]any, rv.Len()) + for i := 0; i < rv.Len(); i++ { + res[i] = relate(rv.Index(i).Interface()) + } + return res + case reflect.Map: + res := make(map[string]any) + keys := rv.MapKeys() + sort.Slice(keys, func(i, j int) bool { + return keys[i].String() < keys[j].String() + }) + + whitelist, isWhitelist := replacer.([]string) + for _, key := range keys { + kStr := key.String() + if isWhitelist { + found := false + for _, w := range whitelist { + if w == kStr { + found = true + break + } + } + if !found { + continue + } + } + res[kStr] = relate(rv.MapIndex(key).Interface()) + } + return res + case reflect.Struct: + res := make(map[string]any) + t := rv.Type() + for i := 0; i < rv.NumField(); i++ { + field := t.Field(i) + if field.PkgPath != "" { + continue + } + name := field.Name + if tag := field.Tag.Get("json"); tag != "" { + name = strings.Split(tag, ",")[0] + } + res[name] = relate(rv.Field(i).Interface()) + } + return res + default: + return v + } + } + + index(value) + output := []any{} + for i := 0; i < len(input); i++ { + output = append(output, transform(input[i])) + } + + var b []byte + var err error + indent := "" + if s, ok := space.(string); ok { + indent = s + } else if i, ok := space.(int); ok { + indent = strings.Repeat(" ", i) + } + + if indent != "" { + b, err = json.MarshalIndent(output, "", indent) + } else { + b, err = json.Marshal(output) + } + + if err != nil { + return "", err + } + return string(b), nil +} + +// Parse converts a specialized flatted string into a Go value. +func Parse(text string, reviver func(key string, value any) any) (any, error) { + var jsonInput []any + if err := json.Unmarshal([]byte(text), &jsonInput); err != nil { + return nil, err + } + + var wrap func(any) any + wrap = func(v any) any { + if s, ok := v.(string); ok { + return flattedIndex(s) + } + if arr, ok := v.([]any); ok { + for i, item := range arr { + arr[i] = wrap(item) + } + return arr + } + if m, ok := v.(map[string]any); ok { + for k, item := range m { + m[k] = wrap(item) + } + return m + } + return v + } + + wrapped := make([]any, len(jsonInput)) + for i, v := range jsonInput { + wrapped[i] = wrap(v) + } + + input := make([]any, len(wrapped)) + for i, v := range wrapped { + if fi, ok := v.(flattedIndex); ok { + input[i] = string(fi) + } else { + input[i] = v + } + } + + if len(input) == 0 { + return nil, nil + } + + value := input[0] + rv := reflect.ValueOf(value) + if rv.IsValid() && (rv.Kind() == reflect.Slice || rv.Kind() == reflect.Map) { + set := make(map[uintptr]bool) + set[rv.Pointer()] = true + res := loop(value, input, set) + if reviver != nil { + return revive("", res, reviver), nil + } + return res, nil + } + + if reviver != nil { + return reviver("", value), nil + } + return value, nil +} + +func revive(key string, value any, reviver func(k string, v any) any) any { + if arr, ok := value.([]any); ok { + for i, v := range arr { + arr[i] = revive(strconv.Itoa(i), v, reviver) + } + } else if m, ok := value.(map[string]any); ok { + keys := make([]string, 0, len(m)) + for k := range m { + keys = append(keys, k) + } + sort.Strings(keys) + for _, k := range keys { + m[k] = revive(k, m[k], reviver) + } + } + return reviver(key, value) +} + +func loop(value any, input []any, set map[uintptr]bool) any { + if arr, ok := value.([]any); ok { + for i, v := range arr { + if fi, ok := v.(flattedIndex); ok { + idx, _ := strconv.Atoi(string(fi)) + arr[i] = ref(input[idx], input, set) + } + } + return arr + } + if m, ok := value.(map[string]any); ok { + for k, v := range m { + if fi, ok := v.(flattedIndex); ok { + idx, _ := strconv.Atoi(string(fi)) + m[k] = ref(input[idx], input, set) + } + } + return m + } + return value +} + +func ref(value any, input []any, set map[uintptr]bool) any { + rv := reflect.ValueOf(value) + if rv.IsValid() && (rv.Kind() == reflect.Slice || rv.Kind() == reflect.Map) { + ptr := rv.Pointer() + if !set[ptr] { + set[ptr] = true + return loop(value, input, set) + } + } + return value +} + +// ToJSON converts a generic value into a JSON serializable object without losing recursion. +func ToJSON(value any) (any, error) { + s, err := Stringify(value, nil, nil) + if err != nil { + return nil, err + } + var res any + err = json.Unmarshal([]byte(s), &res) + return res, err +} + +// FromJSON converts a previously serialized object with recursion into a recursive one. +func FromJSON(value any) (any, error) { + b, err := json.Marshal(value) + if err != nil { + return nil, err + } + return Parse(string(b), nil) +} diff --git a/tools/ui/node_modules/flatted/index.js b/tools/ui/node_modules/flatted/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9386548bf62da3c50b146e3781f4c9ca4519a3de --- /dev/null +++ b/tools/ui/node_modules/flatted/index.js @@ -0,0 +1,155 @@ +self.Flatted = (function (exports) { + 'use strict'; + + function _typeof(o) { + "@babel/helpers - typeof"; + + return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { + return typeof o; + } : function (o) { + return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; + }, _typeof(o); + } + + /// + + // (c) 2020-present Andrea Giammarchi + + var $parse = JSON.parse, + $stringify = JSON.stringify; + var keys = Object.keys; + var Primitive = String; // it could be Number + var primitive = 'string'; // it could be 'number' + + var ignore = {}; + var object = 'object'; + var noop = function noop(_, value) { + return value; + }; + var primitives = function primitives(value) { + return value instanceof Primitive ? Primitive(value) : value; + }; + var Primitives = function Primitives(_, value) { + return _typeof(value) === primitive ? new Primitive(value) : value; + }; + var resolver = function resolver(input, lazy, parsed, $) { + return function (output) { + for (var ke = keys(output), length = ke.length, y = 0; y < length; y++) { + var k = ke[y]; + var value = output[k]; + if (value instanceof Primitive) { + var tmp = input[+value]; + if (_typeof(tmp) === object && !parsed.has(tmp)) { + parsed.add(tmp); + output[k] = ignore; + lazy.push({ + o: output, + k: k, + r: tmp + }); + } else output[k] = $.call(output, k, tmp); + } else if (output[k] !== ignore) output[k] = $.call(output, k, value); + } + return output; + }; + }; + var set = function set(known, input, value) { + var index = Primitive(input.push(value) - 1); + known.set(value, index); + return index; + }; + + /** + * Converts a specialized flatted string into a JS value. + * @param {string} text + * @param {(this: any, key: string, value: any) => any} [reviver] + * @returns {any} + */ + var parse = function parse(text, reviver) { + var input = $parse(text, Primitives).map(primitives); + var $ = reviver || noop; + var value = input[0]; + if (_typeof(value) === object && value) { + var lazy = []; + var revive = resolver(input, lazy, new Set(), $); + value = revive(value); + var i = 0; + while (i < lazy.length) { + // it could be a lazy.shift() but that's costly + var _lazy$i = lazy[i++], + o = _lazy$i.o, + k = _lazy$i.k, + r = _lazy$i.r; + o[k] = $.call(o, k, revive(r)); + } + } + return $.call({ + '': value + }, '', value); + }; + + /** + * Converts a JS value into a specialized flatted string. + * @param {any} value + * @param {((this: any, key: string, value: any) => any) | (string | number)[] | null | undefined} [replacer] + * @param {string | number | undefined} [space] + * @returns {string} + */ + var stringify = function stringify(value, replacer, space) { + var $ = replacer && _typeof(replacer) === object ? function (k, v) { + return k === '' || -1 < replacer.indexOf(k) ? v : void 0; + } : replacer || noop; + var known = new Map(); + var input = []; + var output = []; + var i = +set(known, input, $.call({ + '': value + }, '', value)); + var firstRun = !i; + while (i < input.length) { + firstRun = true; + output[i] = $stringify(input[i++], replace, space); + } + return '[' + output.join(',') + ']'; + function replace(key, value) { + if (firstRun) { + firstRun = !firstRun; + return value; + } + var after = $.call(this, key, value); + switch (_typeof(after)) { + case object: + if (after === null) return after; + case primitive: + return known.get(after) || set(known, input, after); + } + return after; + } + }; + + /** + * Converts a generic value into a JSON serializable object without losing recursion. + * @param {any} value + * @returns {any} + */ + var toJSON = function toJSON(value) { + return $parse(stringify(value)); + }; + + /** + * Converts a previously serialized object with recursion into a recursive one. + * @param {any} value + * @returns {any} + */ + var fromJSON = function fromJSON(value) { + return parse($stringify(value)); + }; + + exports.fromJSON = fromJSON; + exports.parse = parse; + exports.stringify = stringify; + exports.toJSON = toJSON; + + return exports; + +})({}); diff --git a/tools/ui/node_modules/flatted/min.js b/tools/ui/node_modules/flatted/min.js new file mode 100644 index 0000000000000000000000000000000000000000..d3a97cbf4de3ea8a688afaf8bd47ff90966ee096 --- /dev/null +++ b/tools/ui/node_modules/flatted/min.js @@ -0,0 +1 @@ +self.Flatted=function(n){"use strict";function t(n){return t="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(n){return typeof n}:function(n){return n&&"function"==typeof Symbol&&n.constructor===Symbol&&n!==Symbol.prototype?"symbol":typeof n},t(n)}var r=JSON.parse,e=JSON.stringify,o=Object.keys,u=String,f="string",i={},c="object",a=function(n,t){return t},l=function(n){return n instanceof u?u(n):n},s=function(n,r){return t(r)===f?new u(r):r},y=function(n,t,r){var e=u(t.push(r)-1);return n.set(r,e),e},p=function(n,e){var f=r(n,s).map(l),y=e||a,p=f[0];if(t(p)===c&&p){var v=[],S=function(n,r,e,f){return function(a){for(var l=o(a),s=l.length,y=0;y ./coverage/lcov.info" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/WebReflection/flatted.git" + }, + "files": [ + "LICENSE", + "README.md", + "cjs/", + "es.js", + "esm.js", + "esm/", + "index.js", + "min.js", + "php/flatted.php", + "python/flatted.py", + "golang/pkg/flatted/flatted.go", + "types/" + ], + "keywords": [ + "circular", + "JSON", + "fast", + "parser", + "minimal" + ], + "author": "Andrea Giammarchi", + "license": "ISC", + "bugs": { + "url": "https://github.com/WebReflection/flatted/issues" + }, + "homepage": "https://github.com/WebReflection/flatted#readme", + "devDependencies": { + "@babel/core": "^7.29.0", + "@babel/preset-env": "^7.29.0", + "@rollup/plugin-babel": "^7.0.0", + "@rollup/plugin-terser": "^1.0.0", + "@ungap/structured-clone": "^1.3.0", + "ascjs": "^6.0.3", + "c8": "^11.0.0", + "circular-json": "^0.5.9", + "circular-json-es6": "^2.0.2", + "flatted-view": "^0.1.1", + "jsan": "^3.1.14", + "rollup": "^4.59.0", + "terser": "^5.46.0", + "typescript": "^5.9.3" + }, + "module": "./esm/index.js", + "type": "module", + "exports": { + ".": { + "types": "./types/index.d.ts", + "import": "./esm/index.js", + "default": "./cjs/index.js" + }, + "./esm": "./esm.js", + "./package.json": "./package.json" + }, + "types": "./types/index.d.ts" +} diff --git a/tools/ui/node_modules/flatted/php/flatted.php b/tools/ui/node_modules/flatted/php/flatted.php new file mode 100644 index 0000000000000000000000000000000000000000..22659f6a01746c10b477cd8948505fc94f997772 --- /dev/null +++ b/tools/ui/node_modules/flatted/php/flatted.php @@ -0,0 +1,156 @@ +value = $value; + } +} + +class Flatted { + + // public utilities + public static function parse($json, $assoc = false, $depth = 512, $options = 0) { + $input = array_map( + 'Flatted::asString', + array_map( + 'Flatted::wrap', + json_decode($json, $assoc, $depth, $options) + ) + ); + $value = &$input[0]; + $set = array(); + $set[] = &$value; + if (is_array($value)) + return Flatted::loop(false, array_keys($value), $input, $set, $value); + if (is_object($value)) + return Flatted::loop(true, Flatted::keys($value), $input, $set, $value); + return $value; + } + + public static function stringify($value, $options = 0, $depth = 512) { + $known = new stdClass; + $known->key = array(); + $known->value = array(); + $input = array(); + $output = array(); + $i = intval(Flatted::index($known, $input, $value)); + while ($i < count($input)) { + $output[$i] = Flatted::transform($known, $input, $input[$i]); + $i++; + } + return json_encode($output, $options, $depth); + } + + // private helpers + private static function asString($value) { + return $value instanceof FlattedString ? $value->value : $value; + } + + private static function index(&$known, &$input, &$value) { + $input[] = &$value; + $index = strval(count($input) - 1); + $known->key[] = &$value; + $known->value[] = &$index; + return $index; + } + + private static function keys(&$value) { + $obj = new ReflectionObject($value); + $props = $obj->getProperties(); + $keys = array(); + foreach ($props as $prop) + $keys[] = $prop->getName(); + return $keys; + } + + private static function loop($obj, $keys, &$input, &$set, &$output) { + foreach ($keys as $key) { + $value = $obj ? $output->$key : $output[$key]; + if ($value instanceof FlattedString) + Flatted::ref($obj, $key, $input[$value->value], $input, $set, $output); + } + return $output; + } + + private static function relate(&$known, &$input, &$value) { + if (is_string($value) || is_array($value) || is_object($value)) { + $key = array_search($value, $known->key, true); + if ($key !== false) + return $known->value[$key]; + return Flatted::index($known, $input, $value); + } + return $value; + } + + private static function ref($obj, &$key, &$value, &$input, &$set, &$output) { + if (is_array($value) && !in_array($value, $set, true)) { + $set[] = $value; + $value = Flatted::loop(false, array_keys($value), $input, $set, $value); + } + elseif (is_object($value) && !in_array($value, $set, true)) { + $set[] = $value; + $value = Flatted::loop(true, Flatted::keys($value), $input, $set, $value); + } + if ($obj) { + $output->$key = &$value; + } + else { + $output[$key] = &$value; + } + } + + private static function transform(&$known, &$input, &$value) { + if (is_array($value)) { + return array_map( + function ($value) use(&$known, &$input) { + return Flatted::relate($known, $input, $value); + }, + $value + ); + } + if (is_object($value)) { + $object = new stdClass; + $keys = Flatted::keys($value); + foreach ($keys as $key) + $object->$key = Flatted::relate($known, $input, $value->$key); + return $object; + } + return $value; + } + + private static function wrap($value) { + if (is_string($value)) { + return new FlattedString($value); + } + if (is_array($value)) { + return array_map('Flatted::wrap', $value); + } + if (is_object($value)) { + $keys = Flatted::keys($value); + foreach ($keys as $key) { + $value->$key = self::wrap($value->$key); + } + } + return $value; + } +} +?> \ No newline at end of file diff --git a/tools/ui/node_modules/flatted/python/flatted.py b/tools/ui/node_modules/flatted/python/flatted.py new file mode 100644 index 0000000000000000000000000000000000000000..261fd4ae3917b6ffd1dce0caa6f585577cbc5673 --- /dev/null +++ b/tools/ui/node_modules/flatted/python/flatted.py @@ -0,0 +1,144 @@ +# ISC License +# +# Copyright (c) 2018-2025, Andrea Giammarchi, @WebReflection +# +# Permission to use, copy, modify, and/or distribute this software for any +# purpose with or without fee is hereby granted, provided that the above +# copyright notice and this permission notice appear in all copies. +# +# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +# AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +# PERFORMANCE OF THIS SOFTWARE. + +import json as _json + +class _Known: + def __init__(self): + self.key = [] + self.value = [] + +class _String: + def __init__(self, value): + self.value = value + +def _array_keys(value): + for i in range(len(value)): + yield i + +def _object_keys(value): + for key in value: + yield key + +def _is_array(value): + return isinstance(value, (list, tuple)) + +def _is_object(value): + return isinstance(value, dict) + +def _is_string(value): + return isinstance(value, str) + +def _index(known, input, value): + input.append(value) + index = str(len(input) - 1) + known.key.append(value) + known.value.append(index) + return index + +def _relate(known, input, value): + if _is_string(value) or _is_array(value) or _is_object(value): + try: + return known.value[known.key.index(value)] + except: + return _index(known, input, value) + + return value + +def _resolver(input, lazy, parsed): + def resolver(output): + keys = _array_keys(output) if _is_array(output) else _object_keys(output) if _is_object(output) else [] + for key in keys: + value = output[key] + if isinstance(value, _String): + tmp = input[int(value.value)] + output[key] = tmp + if (_is_array(tmp) or _is_object(tmp)) and tmp not in parsed: + parsed.append(tmp) + lazy.append([output, key]) + + return output + + return resolver + +def _transform(known, input, value): + if _is_array(value): + output = [] + for val in value: + output.append(_relate(known, input, val)) + return output + + if _is_object(value): + obj = {} + for key in value: + obj[key] = _relate(known, input, value[key]) + return obj + + return value + +def _wrap(value): + if _is_string(value): + return _String(value) + + if _is_array(value): + i = 0 + for val in value: + value[i] = _wrap(val) + i += 1 + + elif _is_object(value): + for key in value: + value[key] = _wrap(value[key]) + + return value + +def parse(value, *args, **kwargs): + json = _json.loads(value, *args, **kwargs) + wrapped = [] + for value in json: + wrapped.append(_wrap(value)) + + input = [] + for value in wrapped: + if isinstance(value, _String): + input.append(value.value) + else: + input.append(value) + + value = input[0] + lazy = [] + revive = _resolver(input, lazy, [value]) + + value = revive(value) + + i = 0 + while i < len(lazy): + o, k = lazy[i] + i += 1 + o[k] = revive(o[k]) + + return value + + +def stringify(value, *args, **kwargs): + known = _Known() + input = [] + output = [] + i = int(_index(known, input, value)) + while i < len(input): + output.append(_transform(known, input, input[i])) + i += 1 + return _json.dumps(output, *args, **kwargs) diff --git a/tools/ui/node_modules/flatted/types/index.d.ts b/tools/ui/node_modules/flatted/types/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..75dac3385ee0c9eaee83d251c7d0caf919645af0 --- /dev/null +++ b/tools/ui/node_modules/flatted/types/index.d.ts @@ -0,0 +1,4 @@ +export function parse(text: string, reviver?: (this: any, key: string, value: any) => any): any; +export function stringify(value: any, replacer?: (string | number)[] | ((this: any, key: string, value: any) => any), space?: string | number | undefined): string; +export function toJSON(value: any): any; +export function fromJSON(value: any): any; diff --git a/tools/ui/node_modules/follow-redirects/LICENSE b/tools/ui/node_modules/follow-redirects/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..742cbada545ef218c598a58dabd7014e1701cb60 --- /dev/null +++ b/tools/ui/node_modules/follow-redirects/LICENSE @@ -0,0 +1,18 @@ +Copyright 2014–present Olivier Lalonde , James Talmage , Ruben Verborgh + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/follow-redirects/README.md b/tools/ui/node_modules/follow-redirects/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fd35b9e16295f386ab3c8a84713fc79eea6d15a1 --- /dev/null +++ b/tools/ui/node_modules/follow-redirects/README.md @@ -0,0 +1,157 @@ +## Follow Redirects + +Drop-in replacement for Node's `http` and `https` modules that automatically follows redirects. + +[![npm version](https://img.shields.io/npm/v/follow-redirects.svg)](https://www.npmjs.com/package/follow-redirects) +[![Build Status](https://github.com/follow-redirects/follow-redirects/workflows/CI/badge.svg)](https://github.com/follow-redirects/follow-redirects/actions) +[![Coverage Status](https://coveralls.io/repos/follow-redirects/follow-redirects/badge.svg?branch=master)](https://coveralls.io/r/follow-redirects/follow-redirects?branch=master) +[![npm downloads](https://img.shields.io/npm/dm/follow-redirects.svg)](https://www.npmjs.com/package/follow-redirects) +[![Sponsor on GitHub](https://img.shields.io/static/v1?label=Sponsor&message=%F0%9F%92%96&logo=GitHub)](https://github.com/sponsors/RubenVerborgh) + +`follow-redirects` provides [request](https://nodejs.org/api/http.html#http_http_request_options_callback) and [get](https://nodejs.org/api/http.html#http_http_get_options_callback) + methods that behave identically to those found on the native [http](https://nodejs.org/api/http.html#http_http_request_options_callback) and [https](https://nodejs.org/api/https.html#https_https_request_options_callback) + modules, with the exception that they will seamlessly follow redirects. + +```javascript +const { http, https } = require('follow-redirects'); + +http.get('http://en.wikipedia.org/', response => { + response.on('data', chunk => { + console.log(chunk); + }); +}).on('error', err => { + console.error(err); +}); +``` + +You can inspect the final redirected URL through the `responseUrl` property on the `response`. +If no redirection happened, `responseUrl` is the original request URL. + +```javascript +const request = https.request({ + host: 'en.wikipedia.org', + path: '/', +}, response => { + console.log(response.responseUrl); + // 'http://duckduckgo.com/robots.txt' +}); +request.end(); +``` + +## Options +### Global options +Global options are set directly on the `follow-redirects` module: + +```javascript +const followRedirects = require('follow-redirects'); +followRedirects.maxRedirects = 10; +followRedirects.maxBodyLength = 20 * 1024 * 1024; // 20 MB +``` + +The following global options are supported: + +- `maxRedirects` (default: `21`) – sets the maximum number of allowed redirects; if exceeded, an error will be emitted. + +- `maxBodyLength` (default: 10MB) – sets the maximum size of the request body; if exceeded, an error will be emitted. + +### Per-request options +Per-request options are set by passing an `options` object: + +```javascript +const url = require('url'); +const { http, https } = require('follow-redirects'); + +const options = url.parse('http://en.wikipedia.org/'); +options.maxRedirects = 10; +options.beforeRedirect = (options, response, request) => { + // Use this to adjust the request options upon redirecting, + // to inspect the latest response headers, + // or to cancel the request by throwing an error + + // response.headers = the redirect response headers + // response.statusCode = the redirect response code (eg. 301, 307, etc.) + + // request.url = the requested URL that resulted in a redirect + // request.headers = the headers in the request that resulted in a redirect + // request.method = the method of the request that resulted in a redirect + if (options.hostname === "example.org") { + options.auth = "user:password"; + } +}; +http.request(options); +``` + +In addition to the [standard HTTP](https://nodejs.org/api/http.html#http_http_request_options_callback) and [HTTPS options](https://nodejs.org/api/https.html#https_https_request_options_callback), +the following per-request options are supported: +- `followRedirects` (default: `true`) – whether redirects should be followed. + +- `maxRedirects` (default: `21`) – sets the maximum number of allowed redirects; if exceeded, an error will be emitted. + +- `maxBodyLength` (default: 10MB) – sets the maximum size of the request body; if exceeded, an error will be emitted. + +- `beforeRedirect` (default: `undefined`) – optionally change the request `options` on redirects, or abort the request by throwing an error. + +- `agents` (default: `undefined`) – sets the `agent` option per protocol, since HTTP and HTTPS use different agents. Example value: `{ http: new http.Agent(), https: new https.Agent() }` + +- `trackRedirects` (default: `false`) – whether to store the redirected response details into the `redirects` array on the response object. + +- `sensitiveHeaders` (default: `[]`) – names of headers to omit when making redirected requests (such as `X-API-Key`, `X-Auth-Token`…) + + +### Advanced usage +By default, `follow-redirects` will use the Node.js default implementations +of [`http`](https://nodejs.org/api/http.html) +and [`https`](https://nodejs.org/api/https.html). +To enable features such as caching and/or intermediate request tracking, +you might instead want to wrap `follow-redirects` around custom protocol implementations: + +```javascript +const { http, https } = require('follow-redirects').wrap({ + http: require('your-custom-http'), + https: require('your-custom-https'), +}); +``` + +Such custom protocols only need an implementation of the `request` method. + +## Browser Usage + +Due to the way the browser works, +the `http` and `https` browser equivalents perform redirects by default. + +By requiring `follow-redirects` this way: +```javascript +const http = require('follow-redirects/http'); +const https = require('follow-redirects/https'); +``` +you can easily tell webpack and friends to replace +`follow-redirect` by the built-in versions: + +```json +{ + "follow-redirects/http" : "http", + "follow-redirects/https" : "https" +} +``` + +## Contributing + +Pull Requests are always welcome. Please [file an issue](https://github.com/follow-redirects/follow-redirects/issues) + detailing your proposal before you invest your valuable time. Additional features and bug fixes should be accompanied + by tests. You can run the test suite locally with a simple `npm test` command. + +## Debug Logging + +`follow-redirects` uses the excellent [debug](https://www.npmjs.com/package/debug) for logging. To turn on logging + set the environment variable `DEBUG=follow-redirects` for debug output from just this module. When running the test + suite it is sometimes advantageous to set `DEBUG=*` to see output from the express server as well. + +## Authors + +- [Ruben Verborgh](https://ruben.verborgh.org/) +- [Olivier Lalonde](mailto:olalonde@gmail.com) +- [James Talmage](mailto:james@talmage.io) + +## License + +[MIT License](https://github.com/follow-redirects/follow-redirects/blob/master/LICENSE) diff --git a/tools/ui/node_modules/follow-redirects/debug.js b/tools/ui/node_modules/follow-redirects/debug.js new file mode 100644 index 0000000000000000000000000000000000000000..decb77dedde56627ef2d50280daa14326a6091e1 --- /dev/null +++ b/tools/ui/node_modules/follow-redirects/debug.js @@ -0,0 +1,15 @@ +var debug; + +module.exports = function () { + if (!debug) { + try { + /* eslint global-require: off */ + debug = require("debug")("follow-redirects"); + } + catch (error) { /* */ } + if (typeof debug !== "function") { + debug = function () { /* */ }; + } + } + debug.apply(null, arguments); +}; diff --git a/tools/ui/node_modules/follow-redirects/http.js b/tools/ui/node_modules/follow-redirects/http.js new file mode 100644 index 0000000000000000000000000000000000000000..695e356174a86759d476ae3c4098206580076fbd --- /dev/null +++ b/tools/ui/node_modules/follow-redirects/http.js @@ -0,0 +1 @@ +module.exports = require("./").http; diff --git a/tools/ui/node_modules/follow-redirects/https.js b/tools/ui/node_modules/follow-redirects/https.js new file mode 100644 index 0000000000000000000000000000000000000000..d21c921d99a7371e8cdeaeee43579f6bc3da77f6 --- /dev/null +++ b/tools/ui/node_modules/follow-redirects/https.js @@ -0,0 +1 @@ +module.exports = require("./").https; diff --git a/tools/ui/node_modules/follow-redirects/index.js b/tools/ui/node_modules/follow-redirects/index.js new file mode 100644 index 0000000000000000000000000000000000000000..3d32523ec32f38db18e05a67551f1948af67c144 --- /dev/null +++ b/tools/ui/node_modules/follow-redirects/index.js @@ -0,0 +1,709 @@ +var url = require("url"); +var URL = url.URL; +var http = require("http"); +var https = require("https"); +var Writable = require("stream").Writable; +var assert = require("assert"); +var debug = require("./debug"); + +// Preventive platform detection +// istanbul ignore next +(function detectUnsupportedEnvironment() { + var looksLikeNode = typeof process !== "undefined"; + var looksLikeBrowser = typeof window !== "undefined" && typeof document !== "undefined"; + var looksLikeV8 = isFunction(Error.captureStackTrace); + if (!looksLikeNode && (looksLikeBrowser || !looksLikeV8)) { + console.warn("The follow-redirects package should be excluded from browser builds."); + } +}()); + +// Whether to use the native URL object or the legacy url module +var useNativeURL = false; +try { + assert(new URL("")); +} +catch (error) { + useNativeURL = error.code === "ERR_INVALID_URL"; +} + +// HTTP headers to drop across HTTP/HTTPS and domain boundaries +var sensitiveHeaders = [ + "Authorization", + "Proxy-Authorization", + "Cookie", +]; + +// URL fields to preserve in copy operations +var preservedUrlFields = [ + "auth", + "host", + "hostname", + "href", + "path", + "pathname", + "port", + "protocol", + "query", + "search", + "hash", +]; + +// Create handlers that pass events from native requests +var events = ["abort", "aborted", "connect", "error", "socket", "timeout"]; +var eventHandlers = Object.create(null); +events.forEach(function (event) { + eventHandlers[event] = function (arg1, arg2, arg3) { + this._redirectable.emit(event, arg1, arg2, arg3); + }; +}); + +// Error types with codes +var InvalidUrlError = createErrorType( + "ERR_INVALID_URL", + "Invalid URL", + TypeError +); +var RedirectionError = createErrorType( + "ERR_FR_REDIRECTION_FAILURE", + "Redirected request failed" +); +var TooManyRedirectsError = createErrorType( + "ERR_FR_TOO_MANY_REDIRECTS", + "Maximum number of redirects exceeded", + RedirectionError +); +var MaxBodyLengthExceededError = createErrorType( + "ERR_FR_MAX_BODY_LENGTH_EXCEEDED", + "Request body larger than maxBodyLength limit" +); +var WriteAfterEndError = createErrorType( + "ERR_STREAM_WRITE_AFTER_END", + "write after end" +); + +// istanbul ignore next +var destroy = Writable.prototype.destroy || noop; + +// An HTTP(S) request that can be redirected +function RedirectableRequest(options, responseCallback) { + // Initialize the request + Writable.call(this); + this._sanitizeOptions(options); + this._options = options; + this._ended = false; + this._ending = false; + this._redirectCount = 0; + this._redirects = []; + this._requestBodyLength = 0; + this._requestBodyBuffers = []; + + // Attach a callback if passed + if (responseCallback) { + this.on("response", responseCallback); + } + + // React to responses of native requests + var self = this; + this._onNativeResponse = function (response) { + try { + self._processResponse(response); + } + catch (cause) { + self.emit("error", cause instanceof RedirectionError ? + cause : new RedirectionError({ cause: cause })); + } + }; + + // Create filter for sensitive HTTP headers + this._headerFilter = new RegExp("^(?:" + + sensitiveHeaders.concat(options.sensitiveHeaders).map(escapeRegex).join("|") + + ")$", "i"); + + // Perform the first request + this._performRequest(); +} +RedirectableRequest.prototype = Object.create(Writable.prototype); + +RedirectableRequest.prototype.abort = function () { + destroyRequest(this._currentRequest); + this._currentRequest.abort(); + this.emit("abort"); +}; + +RedirectableRequest.prototype.destroy = function (error) { + destroyRequest(this._currentRequest, error); + destroy.call(this, error); + return this; +}; + +// Writes buffered data to the current native request +RedirectableRequest.prototype.write = function (data, encoding, callback) { + // Writing is not allowed if end has been called + if (this._ending) { + throw new WriteAfterEndError(); + } + + // Validate input and shift parameters if necessary + if (!isString(data) && !isBuffer(data)) { + throw new TypeError("data should be a string, Buffer or Uint8Array"); + } + if (isFunction(encoding)) { + callback = encoding; + encoding = null; + } + + // Ignore empty buffers, since writing them doesn't invoke the callback + // https://github.com/nodejs/node/issues/22066 + if (data.length === 0) { + if (callback) { + callback(); + } + return; + } + // Only write when we don't exceed the maximum body length + if (this._requestBodyLength + data.length <= this._options.maxBodyLength) { + this._requestBodyLength += data.length; + this._requestBodyBuffers.push({ data: data, encoding: encoding }); + this._currentRequest.write(data, encoding, callback); + } + // Error when we exceed the maximum body length + else { + this.emit("error", new MaxBodyLengthExceededError()); + this.abort(); + } +}; + +// Ends the current native request +RedirectableRequest.prototype.end = function (data, encoding, callback) { + // Shift parameters if necessary + if (isFunction(data)) { + callback = data; + data = encoding = null; + } + else if (isFunction(encoding)) { + callback = encoding; + encoding = null; + } + + // Write data if needed and end + if (!data) { + this._ended = this._ending = true; + this._currentRequest.end(null, null, callback); + } + else { + var self = this; + var currentRequest = this._currentRequest; + this.write(data, encoding, function () { + self._ended = true; + currentRequest.end(null, null, callback); + }); + this._ending = true; + } +}; + +// Sets a header value on the current native request +RedirectableRequest.prototype.setHeader = function (name, value) { + this._options.headers[name] = value; + this._currentRequest.setHeader(name, value); +}; + +// Clears a header value on the current native request +RedirectableRequest.prototype.removeHeader = function (name) { + delete this._options.headers[name]; + this._currentRequest.removeHeader(name); +}; + +// Global timeout for all underlying requests +RedirectableRequest.prototype.setTimeout = function (msecs, callback) { + var self = this; + + // Destroys the socket on timeout + function destroyOnTimeout(socket) { + socket.setTimeout(msecs); + socket.removeListener("timeout", socket.destroy); + socket.addListener("timeout", socket.destroy); + } + + // Sets up a timer to trigger a timeout event + function startTimer(socket) { + if (self._timeout) { + clearTimeout(self._timeout); + } + self._timeout = setTimeout(function () { + self.emit("timeout"); + clearTimer(); + }, msecs); + destroyOnTimeout(socket); + } + + // Stops a timeout from triggering + function clearTimer() { + // Clear the timeout + if (self._timeout) { + clearTimeout(self._timeout); + self._timeout = null; + } + + // Clean up all attached listeners + self.removeListener("abort", clearTimer); + self.removeListener("error", clearTimer); + self.removeListener("response", clearTimer); + self.removeListener("close", clearTimer); + if (callback) { + self.removeListener("timeout", callback); + } + if (!self.socket) { + self._currentRequest.removeListener("socket", startTimer); + } + } + + // Attach callback if passed + if (callback) { + this.on("timeout", callback); + } + + // Start the timer if or when the socket is opened + if (this.socket) { + startTimer(this.socket); + } + else { + this._currentRequest.once("socket", startTimer); + } + + // Clean up on events + this.on("socket", destroyOnTimeout); + this.on("abort", clearTimer); + this.on("error", clearTimer); + this.on("response", clearTimer); + this.on("close", clearTimer); + + return this; +}; + +// Proxy all other public ClientRequest methods +[ + "flushHeaders", "getHeader", + "setNoDelay", "setSocketKeepAlive", +].forEach(function (method) { + RedirectableRequest.prototype[method] = function (a, b) { + return this._currentRequest[method](a, b); + }; +}); + +// Proxy all public ClientRequest properties +["aborted", "connection", "socket"].forEach(function (property) { + Object.defineProperty(RedirectableRequest.prototype, property, { + get: function () { return this._currentRequest[property]; }, + }); +}); + +RedirectableRequest.prototype._sanitizeOptions = function (options) { + // Ensure headers are always present + if (!options.headers) { + options.headers = {}; + } + if (!isArray(options.sensitiveHeaders)) { + options.sensitiveHeaders = []; + } + + // Since http.request treats host as an alias of hostname, + // but the url module interprets host as hostname plus port, + // eliminate the host property to avoid confusion. + if (options.host) { + // Use hostname if set, because it has precedence + if (!options.hostname) { + options.hostname = options.host; + } + delete options.host; + } + + // Complete the URL object when necessary + if (!options.pathname && options.path) { + var searchPos = options.path.indexOf("?"); + if (searchPos < 0) { + options.pathname = options.path; + } + else { + options.pathname = options.path.substring(0, searchPos); + options.search = options.path.substring(searchPos); + } + } +}; + + +// Executes the next native request (initial or redirect) +RedirectableRequest.prototype._performRequest = function () { + // Load the native protocol + var protocol = this._options.protocol; + var nativeProtocol = this._options.nativeProtocols[protocol]; + if (!nativeProtocol) { + throw new TypeError("Unsupported protocol " + protocol); + } + + // If specified, use the agent corresponding to the protocol + // (HTTP and HTTPS use different types of agents) + if (this._options.agents) { + var scheme = protocol.slice(0, -1); + this._options.agent = this._options.agents[scheme]; + } + + // Create the native request and set up its event handlers + var request = this._currentRequest = + nativeProtocol.request(this._options, this._onNativeResponse); + request._redirectable = this; + for (var event of events) { + request.on(event, eventHandlers[event]); + } + + // RFC7230§5.3.1: When making a request directly to an origin server, […] + // a client MUST send only the absolute path […] as the request-target. + this._currentUrl = /^\//.test(this._options.path) ? + url.format(this._options) : + // When making a request to a proxy, […] + // a client MUST send the target URI in absolute-form […]. + this._options.path; + + // End a redirected request + // (The first request must be ended explicitly with RedirectableRequest#end) + if (this._isRedirect) { + // Write the request entity and end + var i = 0; + var self = this; + var buffers = this._requestBodyBuffers; + (function writeNext(error) { + // Only write if this request has not been redirected yet + // istanbul ignore else + if (request === self._currentRequest) { + // Report any write errors + // istanbul ignore if + if (error) { + self.emit("error", error); + } + // Write the next buffer if there are still left + else if (i < buffers.length) { + var buffer = buffers[i++]; + // istanbul ignore else + if (!request.finished) { + request.write(buffer.data, buffer.encoding, writeNext); + } + } + // End the request if `end` has been called on us + else if (self._ended) { + request.end(); + } + } + }()); + } +}; + +// Processes a response from the current native request +RedirectableRequest.prototype._processResponse = function (response) { + // Store the redirected response + var statusCode = response.statusCode; + if (this._options.trackRedirects) { + this._redirects.push({ + url: this._currentUrl, + headers: response.headers, + statusCode: statusCode, + }); + } + + // RFC7231§6.4: The 3xx (Redirection) class of status code indicates + // that further action needs to be taken by the user agent in order to + // fulfill the request. If a Location header field is provided, + // the user agent MAY automatically redirect its request to the URI + // referenced by the Location field value, + // even if the specific status code is not understood. + + // If the response is not a redirect; return it as-is + var location = response.headers.location; + if (!location || this._options.followRedirects === false || + statusCode < 300 || statusCode >= 400) { + response.responseUrl = this._currentUrl; + response.redirects = this._redirects; + this.emit("response", response); + + // Clean up + this._requestBodyBuffers = []; + return; + } + + // The response is a redirect, so abort the current request + destroyRequest(this._currentRequest); + // Discard the remainder of the response to avoid waiting for data + response.destroy(); + + // RFC7231§6.4: A client SHOULD detect and intervene + // in cyclical redirections (i.e., "infinite" redirection loops). + if (++this._redirectCount > this._options.maxRedirects) { + throw new TooManyRedirectsError(); + } + + // Store the request headers if applicable + var requestHeaders; + var beforeRedirect = this._options.beforeRedirect; + if (beforeRedirect) { + requestHeaders = Object.assign({ + // The Host header was set by nativeProtocol.request + Host: response.req.getHeader("host"), + }, this._options.headers); + } + + // RFC7231§6.4: Automatic redirection needs to done with + // care for methods not known to be safe, […] + // RFC7231§6.4.2–3: For historical reasons, a user agent MAY change + // the request method from POST to GET for the subsequent request. + var method = this._options.method; + if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" || + // RFC7231§6.4.4: The 303 (See Other) status code indicates that + // the server is redirecting the user agent to a different resource […] + // A user agent can perform a retrieval request targeting that URI + // (a GET or HEAD request if using HTTP) […] + (statusCode === 303) && !/^(?:GET|HEAD)$/.test(this._options.method)) { + this._options.method = "GET"; + // Drop a possible entity and headers related to it + this._requestBodyBuffers = []; + removeMatchingHeaders(/^content-/i, this._options.headers); + } + + // Drop the Host header, as the redirect might lead to a different host + var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers); + + // If the redirect is relative, carry over the host of the last request + var currentUrlParts = parseUrl(this._currentUrl); + var currentHost = currentHostHeader || currentUrlParts.host; + var currentUrl = /^\w+:/.test(location) ? this._currentUrl : + url.format(Object.assign(currentUrlParts, { host: currentHost })); + + // Create the redirected request + var redirectUrl = resolveUrl(location, currentUrl); + debug("redirecting to", redirectUrl.href); + this._isRedirect = true; + spreadUrlObject(redirectUrl, this._options); + + // Drop confidential headers when redirecting to a less secure protocol + // or to a different domain that is not a superdomain + if (redirectUrl.protocol !== currentUrlParts.protocol && + redirectUrl.protocol !== "https:" || + redirectUrl.host !== currentHost && + !isSubdomain(redirectUrl.host, currentHost)) { + removeMatchingHeaders(this._headerFilter, this._options.headers); + } + + // Evaluate the beforeRedirect callback + if (isFunction(beforeRedirect)) { + var responseDetails = { + headers: response.headers, + statusCode: statusCode, + }; + var requestDetails = { + url: currentUrl, + method: method, + headers: requestHeaders, + }; + beforeRedirect(this._options, responseDetails, requestDetails); + this._sanitizeOptions(this._options); + } + + // Perform the redirected request + this._performRequest(); +}; + +// Wraps the key/value object of protocols with redirect functionality +function wrap(protocols) { + // Default settings + var exports = { + maxRedirects: 21, + maxBodyLength: 10 * 1024 * 1024, + }; + + // Wrap each protocol + var nativeProtocols = {}; + Object.keys(protocols).forEach(function (scheme) { + var protocol = scheme + ":"; + var nativeProtocol = nativeProtocols[protocol] = protocols[scheme]; + var wrappedProtocol = exports[scheme] = Object.create(nativeProtocol); + + // Executes a request, following redirects + function request(input, options, callback) { + // Parse parameters, ensuring that input is an object + if (isURL(input)) { + input = spreadUrlObject(input); + } + else if (isString(input)) { + input = spreadUrlObject(parseUrl(input)); + } + else { + callback = options; + options = validateUrl(input); + input = { protocol: protocol }; + } + if (isFunction(options)) { + callback = options; + options = null; + } + + // Set defaults + options = Object.assign({ + maxRedirects: exports.maxRedirects, + maxBodyLength: exports.maxBodyLength, + }, input, options); + options.nativeProtocols = nativeProtocols; + if (!isString(options.host) && !isString(options.hostname)) { + options.hostname = "::1"; + } + + assert.equal(options.protocol, protocol, "protocol mismatch"); + debug("options", options); + return new RedirectableRequest(options, callback); + } + + // Executes a GET request, following redirects + function get(input, options, callback) { + var wrappedRequest = wrappedProtocol.request(input, options, callback); + wrappedRequest.end(); + return wrappedRequest; + } + + // Expose the properties on the wrapped protocol + Object.defineProperties(wrappedProtocol, { + request: { value: request, configurable: true, enumerable: true, writable: true }, + get: { value: get, configurable: true, enumerable: true, writable: true }, + }); + }); + return exports; +} + +function noop() { /* empty */ } + +function parseUrl(input) { + var parsed; + // istanbul ignore else + if (useNativeURL) { + parsed = new URL(input); + } + else { + // Ensure the URL is valid and absolute + parsed = validateUrl(url.parse(input)); + if (!isString(parsed.protocol)) { + throw new InvalidUrlError({ input }); + } + } + return parsed; +} + +function resolveUrl(relative, base) { + // istanbul ignore next + return useNativeURL ? new URL(relative, base) : parseUrl(url.resolve(base, relative)); +} + +function validateUrl(input) { + if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) { + throw new InvalidUrlError({ input: input.href || input }); + } + if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) { + throw new InvalidUrlError({ input: input.href || input }); + } + return input; +} + +function spreadUrlObject(urlObject, target) { + var spread = target || {}; + for (var key of preservedUrlFields) { + spread[key] = urlObject[key]; + } + + // Fix IPv6 hostname + if (spread.hostname.startsWith("[")) { + spread.hostname = spread.hostname.slice(1, -1); + } + // Ensure port is a number + if (spread.port !== "") { + spread.port = Number(spread.port); + } + // Concatenate path + spread.path = spread.search ? spread.pathname + spread.search : spread.pathname; + + return spread; +} + +function removeMatchingHeaders(regex, headers) { + var lastValue; + for (var header in headers) { + if (regex.test(header)) { + lastValue = headers[header]; + delete headers[header]; + } + } + return (lastValue === null || typeof lastValue === "undefined") ? + undefined : String(lastValue).trim(); +} + +function createErrorType(code, message, baseClass) { + // Create constructor + function CustomError(properties) { + // istanbul ignore else + if (isFunction(Error.captureStackTrace)) { + Error.captureStackTrace(this, this.constructor); + } + Object.assign(this, properties || {}); + this.code = code; + this.message = this.cause ? message + ": " + this.cause.message : message; + } + + // Attach constructor and set default properties + CustomError.prototype = new (baseClass || Error)(); + Object.defineProperties(CustomError.prototype, { + constructor: { + value: CustomError, + enumerable: false, + }, + name: { + value: "Error [" + code + "]", + enumerable: false, + }, + }); + return CustomError; +} + +function destroyRequest(request, error) { + for (var event of events) { + request.removeListener(event, eventHandlers[event]); + } + request.on("error", noop); + request.destroy(error); +} + +function isSubdomain(subdomain, domain) { + assert(isString(subdomain) && isString(domain)); + var dot = subdomain.length - domain.length - 1; + return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain); +} + +function isArray(value) { + return value instanceof Array; +} + +function isString(value) { + return typeof value === "string" || value instanceof String; +} + +function isFunction(value) { + return typeof value === "function"; +} + +function isBuffer(value) { + return typeof value === "object" && ("length" in value); +} + +function isURL(value) { + return URL && value instanceof URL; +} + +function escapeRegex(regex) { + return regex.replace(/[\]\\/()*+?.$]/g, "\\$&"); +} + +// Exports +module.exports = wrap({ http: http, https: https }); +module.exports.wrap = wrap; diff --git a/tools/ui/node_modules/follow-redirects/package.json b/tools/ui/node_modules/follow-redirects/package.json new file mode 100644 index 0000000000000000000000000000000000000000..1027c77095c649a0ab54f77fd61b5662e71195a5 --- /dev/null +++ b/tools/ui/node_modules/follow-redirects/package.json @@ -0,0 +1,58 @@ +{ + "name": "follow-redirects", + "version": "1.16.0", + "description": "HTTP and HTTPS modules that follow redirects.", + "license": "MIT", + "main": "index.js", + "files": [ + "*.js" + ], + "engines": { + "node": ">=4.0" + }, + "scripts": { + "lint": "eslint *.js test", + "test": "nyc mocha" + }, + "repository": { + "type": "git", + "url": "git+ssh://git@github.com/follow-redirects/follow-redirects.git" + }, + "homepage": "https://github.com/follow-redirects/follow-redirects", + "bugs": { + "url": "https://github.com/follow-redirects/follow-redirects/issues" + }, + "keywords": [ + "http", + "https", + "url", + "redirect", + "client", + "location", + "utility" + ], + "author": "Ruben Verborgh (https://ruben.verborgh.org/)", + "contributors": [ + "Olivier Lalonde (http://www.syskall.com)", + "James Talmage " + ], + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "peerDependenciesMeta": { + "debug": { + "optional": true + } + }, + "devDependencies": { + "concat-stream": "^2.0.0", + "eslint": "^5.16.0", + "express": "^4.16.4", + "lolex": "^3.1.0", + "mocha": "^6.0.2", + "nyc": "^14.1.1" + } +} diff --git a/tools/ui/node_modules/for-each/.editorconfig b/tools/ui/node_modules/for-each/.editorconfig new file mode 100644 index 0000000000000000000000000000000000000000..ac29adef0361c66b058a66a44ec2a0fd0b1a2207 --- /dev/null +++ b/tools/ui/node_modules/for-each/.editorconfig @@ -0,0 +1,20 @@ +root = true + +[*] +indent_style = tab +indent_size = 4 +end_of_line = lf +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true +max_line_length = 120 + +[CHANGELOG.md] +indent_style = space +indent_size = 2 + +[*.json] +max_line_length = off + +[Makefile] +max_line_length = off diff --git a/tools/ui/node_modules/for-each/.eslintrc b/tools/ui/node_modules/for-each/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..9b811fa447fbb1de7da08d719aa2753cc6bea806 --- /dev/null +++ b/tools/ui/node_modules/for-each/.eslintrc @@ -0,0 +1,30 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "eqeqeq": [2, "allow-null"], + "func-name-matching": 0, + "func-style": 0, + "indent": [2, 4], + "max-nested-callbacks": [2, 3], + "max-params": [2, 3], + "max-statements": [2, 14], + "no-extra-parens": 0, + "no-invalid-this": 1, + "no-restricted-syntax": [2, "BreakStatement", "ContinueStatement", "DebuggerStatement", "LabeledStatement", "WithStatement"], + }, + + "overrides": [ + { + "files": "test/**", + "rules": { + "array-bracket-newline": 0, + "array-element-newline": 0, + "max-statements-per-line": 0, + "no-magic-numbers": 0, + }, + }, + ], +} diff --git a/tools/ui/node_modules/for-each/.github/FUNDING.yml b/tools/ui/node_modules/for-each/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..5ce5b3a62f36cd851c865de61b745b814b1ae4c6 --- /dev/null +++ b/tools/ui/node_modules/for-each/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/for-each +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/for-each/.github/SECURITY.md b/tools/ui/node_modules/for-each/.github/SECURITY.md new file mode 100644 index 0000000000000000000000000000000000000000..82e4285adc6285693cd6c06af02d606e09dd8fcd --- /dev/null +++ b/tools/ui/node_modules/for-each/.github/SECURITY.md @@ -0,0 +1,3 @@ +# Security + +Please email [@ljharb](https://github.com/ljharb) or see https://tidelift.com/security if you have a potential security vulnerability to report. diff --git a/tools/ui/node_modules/for-each/.nycrc b/tools/ui/node_modules/for-each/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..b7b8240afc9d1d7fb65126e9b13c3502dbd6abc5 --- /dev/null +++ b/tools/ui/node_modules/for-each/.nycrc @@ -0,0 +1,8 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage" + ] +} diff --git a/tools/ui/node_modules/for-each/CHANGELOG.md b/tools/ui/node_modules/for-each/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..06b5bc0756671dae2c301f50834b035addb38454 --- /dev/null +++ b/tools/ui/node_modules/for-each/CHANGELOG.md @@ -0,0 +1,107 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v0.3.5](https://github.com/ljharb/for-each/compare/v0.3.4...v0.3.5) - 2025-02-10 + +### Commits + +- [New] add types [`6483c1e`](https://github.com/ljharb/for-each/commit/6483c1e9b6177e5ca9ba506188300c5a25de26c2) + +## [v0.3.4](https://github.com/ljharb/for-each/compare/v0.3.3...v0.3.4) - 2025-01-24 + +### Commits + +- [meta] use `auto-changelog` [`c16ee6a`](https://github.com/ljharb/for-each/commit/c16ee6a125eb3c6d30f626b4b02ec849a63fca28) +- [Tests] add github actions [`379b59c`](https://github.com/ljharb/for-each/commit/379b59c8f282c2281ba668e3e028ad6410afb99b) +- [meta] delete `.travis.yml` [`09e5c77`](https://github.com/ljharb/for-each/commit/09e5c779651215c41bd4727e266a5e7ebb3b0a4d) +- [Dev Deps] update eslint things [`9163b86`](https://github.com/ljharb/for-each/commit/9163b86435be325965f096ac17793a0e783b1c1e) +- [meta] consolidate eslintrc files [`f2ab52b`](https://github.com/ljharb/for-each/commit/f2ab52b6944fe8c1a189957889276950393eddb3) +- [meta] add `funding` field and `FUNDING.yml` [`05d21b3`](https://github.com/ljharb/for-each/commit/05d21b382ccd4627b283d1a31c49935c7d79fd57) +- [Tests] up to `node` `v10`; use `nvm install-latest-npm` [`7c06cbd`](https://github.com/ljharb/for-each/commit/7c06cbdabea81ba029cd466545dea5cb9f24f528) +- [Tests] add `nyc` [`0f4643e`](https://github.com/ljharb/for-each/commit/0f4643e6a572bdc6967a17be8e7b959600edbbd2) +- [meta] use `npmignore` [`39a975c`](https://github.com/ljharb/for-each/commit/39a975c8c6050586b93b5e0a98b20be44d1b38d4) +- [meta] remove unnecessary `licenses` key [`3d064f1`](https://github.com/ljharb/for-each/commit/3d064f12167c12d8e1d1ee1447ee58d8211c63e1) +- [Tests] use `npm audit` instead of long-dead `nsp` [`d4c722a`](https://github.com/ljharb/for-each/commit/d4c722a0f61f61d93965328f436f87421bce9973) +- [Dev Deps] update `tape` [`552c1ae`](https://github.com/ljharb/for-each/commit/552c1ae6a01728ff312d47605dbdb961ef0ccbcc) +- Update README.md [`d19acc2`](https://github.com/ljharb/for-each/commit/d19acc23624eed9d8f59b9fa64e6e3cba638aa52) +- [meta] add missing `engines.node` [`8889b49`](https://github.com/ljharb/for-each/commit/8889b49bd737d7a72c2a515eb2ee39a01c813bac) +- [meta] create SECURITY.md [`9069d42`](https://github.com/ljharb/for-each/commit/9069d42d245b02ae7c5f0c193fceb55427436e4e) +- [Deps] update `is-callable` [`bfa51d1`](https://github.com/ljharb/for-each/commit/bfa51d18018477843147bcdcc6cc63eb045151f5) + +## [v0.3.3](https://github.com/ljharb/for-each/compare/v0.3.2...v0.3.3) - 2018-06-01 + +### Commits + +- Add `npm run lint`, `npm run jscs`, and `npm run eslint` [`4a17d99`](https://github.com/ljharb/for-each/commit/4a17d99d7397dd2356530d238e0e6c37ef34a1d5) +- Style cleanup: [`1df6824`](https://github.com/ljharb/for-each/commit/1df6824d96bfc293c0c9e6b78143b602c8d94986) +- Update `eslint`, `tape`; use my personal shared `eslint` config. [`b8e7d85`](https://github.com/ljharb/for-each/commit/b8e7d850ec9010a7171d34297f7af74b90f28aac) +- [Tests] remove jscs [`37e3557`](https://github.com/ljharb/for-each/commit/37e355784b4261dcf5004158a72c4b8a6c6c524f) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `nsp`, `tape`; fix scripts [`566045d`](https://github.com/ljharb/for-each/commit/566045d84f2ee5dff7cc14805c4fdb1d13d2624d) +- [Tests] up to `node` `v8`; newer npm breaks on older node [`07177dc`](https://github.com/ljharb/for-each/commit/07177dc9c8419b2a887c727ec576189a7c8e7837) +- Run `npm run lint` as part of tests. [`a34ea05`](https://github.com/ljharb/for-each/commit/a34ea05f729e0987007670d5693e093c56865ef6) +- Update `travis.yml` to test on the latest `node` and `io.js` [`354c843`](https://github.com/ljharb/for-each/commit/354c8434a166c7095c613e818c8d542fd1e2d630) +- Update `eslint` [`3601c93`](https://github.com/ljharb/for-each/commit/3601c9348e2cfb29ed3cfee352c2c95d4a8de87f) +- Update `tape`, `jscs`, `eslint`, `@ljharb/eslint-config` [`1aaff65`](https://github.com/ljharb/for-each/commit/1aaff65a55d8a054561251c6a2501c4dc42e1f99) +- Only use `Function#call` to call the callback if the receiver is supplied, for performance. [`54b4775`](https://github.com/ljharb/for-each/commit/54b477571b4d7c11edccafd94f2e16380892ee5d) +- [Dev Deps] update `jscs`, `eslint`, `@ljharb/eslint-config`, `nsp` [`6ba1cb8`](https://github.com/ljharb/for-each/commit/6ba1cb8a708e84ba4bb4067d31549829ec579d92) +- [Dev Deps] update `tape`, `eslint`, `jscs` [`8f5e1d5`](https://github.com/ljharb/for-each/commit/8f5e1d5fcabaf3abaa6ce2d3e6dd095f0dedfc4e) +- Add "license" to `package.json`, matching the LICENSE file. [`defc2c3`](https://github.com/ljharb/for-each/commit/defc2c35ffa7c9d4fbcf846f28b436f0083a381c) +- Update `eslint` [`05d1850`](https://github.com/ljharb/for-each/commit/05d18503dd0ec709f93df5c905bd2d0ce51323c3) +- [Tests] on `io.js` `v3.3`, `node` `v4.0` [`e8395a4`](https://github.com/ljharb/for-each/commit/e8395a43feef399299839c8d466ddd9dca0c3268) +- Add `npm run security` [`0a45177`](https://github.com/ljharb/for-each/commit/0a45177290b1de71094ddd322ef4a504458e901d) +- Only apps should have lockfiles. [`6268d7b`](https://github.com/ljharb/for-each/commit/6268d7b39edd06ef5a283c7afdb6c823077db777) +- [Dev Deps] update `nsp`, `tape`, `eslint` [`b95939f`](https://github.com/ljharb/for-each/commit/b95939f66a3dad590b3bc42c53535e77c1bfc114) +- Use `is-callable` instead of `is-function`, to cover ES6 environments with `Symbol.toStringTag` [`4095d33`](https://github.com/ljharb/for-each/commit/4095d334581c1caee92f595c299ffc479806dc3f) +- Test on `io.js` `v2.2` [`7b44f98`](https://github.com/ljharb/for-each/commit/7b44f98c217291a92385ddd3903d4974e049d762) +- Some old browsers choke on variables named "toString". [`4f1b626`](https://github.com/ljharb/for-each/commit/4f1b626eb91fcdc0e9018472a702aea713799190) +- Update `is-function`, `tape` [`3ceaf32`](https://github.com/ljharb/for-each/commit/3ceaf3240ef7d1b261cf510eb932cf540291187b) +- Test up to `io.js` `v3.0` [`3c1377a`](https://github.com/ljharb/for-each/commit/3c1377a31adf003323f4846a97e8f7c8fd51b5d2) +- [Deps] update `is-callable` [`f5c62d0`](https://github.com/ljharb/for-each/commit/f5c62d034b582a15bcb1f1cadace4e9c84f1780a) +- Test on `io.js` `v2.4` [`db86c85`](https://github.com/ljharb/for-each/commit/db86c85641d053a1dc4e570e8c8afbea915f78c0) +- Test on `io.js` `v2.3` [`2f04ca8`](https://github.com/ljharb/for-each/commit/2f04ca885adb4a8ccca658739f771a7f78522d03) + +## [v0.3.2](https://github.com/ljharb/for-each/compare/v0.3.1...v0.3.2) - 2014-01-07 + +### Merged + +- works down to IE6 [`#5`](https://github.com/ljharb/for-each/pull/5) + +## [v0.3.1](https://github.com/ljharb/for-each/compare/v0.3.0...v0.3.1) - 2014-01-06 + +## [v0.3.0](https://github.com/ljharb/for-each/compare/v0.2.0...v0.3.0) - 2014-01-06 + +### Merged + +- remove use of Object.keys [`#4`](https://github.com/ljharb/for-each/pull/4) +- Update tape. [`#3`](https://github.com/ljharb/for-each/pull/3) +- regex is not a function [`#2`](https://github.com/ljharb/for-each/pull/2) +- Add testling [`#1`](https://github.com/ljharb/for-each/pull/1) + +### Commits + +- Add testling. [`a24b521`](https://github.com/ljharb/for-each/commit/a24b52111937d509a3b5f58106c8835283de7146) +- Add array example to README [`9bd70c2`](https://github.com/ljharb/for-each/commit/9bd70c2ceafddfc734a80e0fea2bbac00afa963a) +- Regexes are considered functions in older browsers. [`403f649`](https://github.com/ljharb/for-each/commit/403f6490f903984adea1771af29c41fd2b1e4b64) +- Adding android browser to testling. [`a4c5825`](https://github.com/ljharb/for-each/commit/a4c5825bf8abd13589b9a9662c9d3deaf89cbf66) + +## [v0.2.0](https://github.com/ljharb/for-each/compare/v0.1.0...v0.2.0) - 2013-05-10 + +### Commits + +- Adding tests. [`7e74213`](https://github.com/ljharb/for-each/commit/7e74213d1b5d01b19249c3e3037302bd7fc74f1c) +- Adding proper array indexing, as well as string support. [`d36f794`](https://github.com/ljharb/for-each/commit/d36f794d6c0c5696bf1e4f8e79ae667858dfc11b) +- Use tape instead of tap. [`016a3cf`](https://github.com/ljharb/for-each/commit/016a3cf706c78037384d4c378b2ebe6e702cbb02) +- Requiring that the iterator is a function. [`cfedced`](https://github.com/ljharb/for-each/commit/cfedceda15ea2f7eb4acf079fb90ce17ec7da664) +- Adding myself as a contributor :-) [`ff28fca`](https://github.com/ljharb/for-each/commit/ff28fca8ec30f6fdbb7af87c74ed35688e60d07a) +- Adding node 0.10 to travis [`75f2460`](https://github.com/ljharb/for-each/commit/75f2460343d3ea58f91dad45f2eda478e3a4e412) + +## v0.1.0 - 2012-09-28 + +### Commits + +- first [`2d3a6ed`](https://github.com/ljharb/for-each/commit/2d3a6ed63036455847937cf00bec56b59ab36a9d) +- docs & travis [`ea4caad`](https://github.com/ljharb/for-each/commit/ea4caad8a8768992dcce29998e226484beed841c) diff --git a/tools/ui/node_modules/for-each/LICENSE b/tools/ui/node_modules/for-each/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..53f19aa771439a54bcc31897e36fb2a8ad3c11ef --- /dev/null +++ b/tools/ui/node_modules/for-each/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2012 Raynos. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/tools/ui/node_modules/for-each/README.md b/tools/ui/node_modules/for-each/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b76561ef1f70c86551d7631075c611665bc11714 --- /dev/null +++ b/tools/ui/node_modules/for-each/README.md @@ -0,0 +1,39 @@ +# for-each [![build status][1]][2] + +[![browser support][3]][4] + +A better forEach. + +## Example + +Like `Array.prototype.forEach` but works on objects. + +```js +var forEach = require("for-each") + +forEach({ key: "value" }, function (value, key, object) { + /* code */ +}) +``` + +As a bonus, it's also a perfectly function shim/polyfill for arrays too! + +```js +var forEach = require("for-each") + +forEach([1, 2, 3], function (value, index, array) { + /* code */ +}) +``` + +## Installation + +`npm install for-each` + +## MIT Licenced + + [1]: https://secure.travis-ci.org/Raynos/for-each.png + [2]: http://travis-ci.org/Raynos/for-each + [3]: https://ci.testling.com/Raynos/for-each.png + [4]: https://ci.testling.com/Raynos/for-each + diff --git a/tools/ui/node_modules/for-each/index.d.ts b/tools/ui/node_modules/for-each/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..90f98de4f7b74b25872d8c040d22b25c513d8811 --- /dev/null +++ b/tools/ui/node_modules/for-each/index.d.ts @@ -0,0 +1,35 @@ +declare function forEach( + arr: O, + callback: (this: This | void, value: O[number], index: number, array: O) => void, + thisArg?: This, +): void; + +declare function forEach, This = undefined>( + arr: O, + callback: (this: This | void, value: O[number], index: number, array: O) => void, + thisArg?: This, +): void; + +declare function forEach( + obj: O, + callback: (this: This | void, value: O[keyof O], key: keyof O, obj: O) => void, + thisArg?: This, +): void; + +declare function forEach( + str: O, + callback: (this: This | void, value: O[number], index: number, str: O) => void, + thisArg: This, +): void; + +export = forEach; + +declare function forEachInternal void, This = undefined>( + value: O, + callback: C, + thisArg?: This, +): void; + +declare namespace forEach { + export type _internal = typeof forEachInternal; +} diff --git a/tools/ui/node_modules/for-each/index.js b/tools/ui/node_modules/for-each/index.js new file mode 100644 index 0000000000000000000000000000000000000000..0af3c44eb49fb153b1c7bc05d812045c9c4acd81 --- /dev/null +++ b/tools/ui/node_modules/for-each/index.js @@ -0,0 +1,69 @@ +'use strict'; + +var isCallable = require('is-callable'); + +var toStr = Object.prototype.toString; +var hasOwnProperty = Object.prototype.hasOwnProperty; + +/** @type {(arr: A, iterator: (this: This | void, value: A[number], index: number, arr: A) => void, receiver: This | undefined) => void} */ +var forEachArray = function forEachArray(array, iterator, receiver) { + for (var i = 0, len = array.length; i < len; i++) { + if (hasOwnProperty.call(array, i)) { + if (receiver == null) { + iterator(array[i], i, array); + } else { + iterator.call(receiver, array[i], i, array); + } + } + } +}; + +/** @type {(string: S, iterator: (this: This | void, value: S[number], index: number, string: S) => void, receiver: This | undefined) => void} */ +var forEachString = function forEachString(string, iterator, receiver) { + for (var i = 0, len = string.length; i < len; i++) { + // no such thing as a sparse string. + if (receiver == null) { + iterator(string.charAt(i), i, string); + } else { + iterator.call(receiver, string.charAt(i), i, string); + } + } +}; + +/** @type {(obj: O, iterator: (this: This | void, value: O[keyof O], index: keyof O, obj: O) => void, receiver: This | undefined) => void} */ +var forEachObject = function forEachObject(object, iterator, receiver) { + for (var k in object) { + if (hasOwnProperty.call(object, k)) { + if (receiver == null) { + iterator(object[k], k, object); + } else { + iterator.call(receiver, object[k], k, object); + } + } + } +}; + +/** @type {(x: unknown) => x is readonly unknown[]} */ +function isArray(x) { + return toStr.call(x) === '[object Array]'; +} + +/** @type {import('.')._internal} */ +module.exports = function forEach(list, iterator, thisArg) { + if (!isCallable(iterator)) { + throw new TypeError('iterator must be a function'); + } + + var receiver; + if (arguments.length >= 3) { + receiver = thisArg; + } + + if (isArray(list)) { + forEachArray(list, iterator, receiver); + } else if (typeof list === 'string') { + forEachString(list, iterator, receiver); + } else { + forEachObject(list, iterator, receiver); + } +}; diff --git a/tools/ui/node_modules/for-each/package.json b/tools/ui/node_modules/for-each/package.json new file mode 100644 index 0000000000000000000000000000000000000000..bf0f5cded82e9638fc05ab93340ea1d583ffa7bd --- /dev/null +++ b/tools/ui/node_modules/for-each/package.json @@ -0,0 +1,76 @@ +{ + "name": "for-each", + "version": "0.3.5", + "description": "A better forEach", + "keywords": [], + "author": "Raynos ", + "repository": { + "type": "git", + "url": "https://github.com/Raynos/for-each.git" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "main": "index", + "homepage": "https://github.com/Raynos/for-each", + "contributors": [ + { + "name": "Jake Verbaten" + }, + { + "name": "Jordan Harband", + "url": "https://github.com/ljharb" + } + ], + "bugs": { + "url": "https://github.com/Raynos/for-each/issues", + "email": "raynos2@gmail.com" + }, + "license": "MIT", + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "pretest": "npm run lint", + "test": "npm run tests-only", + "tests-only": "nyc tape 'test/*.js'", + "posttest": "npx npm@\">= 10.2\" audit --production", + "lint": "eslint --ext=js,mjs .", + "postlint": "tsc && attw -P", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "dependencies": { + "is-callable": "^1.2.7" + }, + "devDependencies": { + "@arethetypeswrong/cli": "^0.17.3", + "@ljharb/eslint-config": "^21.1.1", + "@ljharb/tsconfig": "^0.2.3", + "@types/is-callable": "^1.1.2", + "@types/tape": "^5.8.1", + "auto-changelog": "^2.5.0", + "eslint": "=8.8.0", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "tape": "^5.9.0", + "typescript": "next" + }, + "testling": { + "files": "test/test.js" + }, + "engines": { + "node": ">= 0.4" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + } +} diff --git a/tools/ui/node_modules/for-each/test/test.js b/tools/ui/node_modules/for-each/test/test.js new file mode 100644 index 0000000000000000000000000000000000000000..455d247eba87a5c7c429c857cbd58f8b816b54c4 --- /dev/null +++ b/tools/ui/node_modules/for-each/test/test.js @@ -0,0 +1,224 @@ +'use strict'; + +var test = require('tape'); +var forEach = require('../'); + +test('forEach calls each iterator', function (t) { + var count = 0; + t.plan(4); + + forEach({ a: 1, b: 2 }, function (value, key) { + if (count === 0) { + t.equal(value, 1); + t.equal(key, 'a'); + } else { + t.equal(value, 2); + t.equal(key, 'b'); + } + count += 1; + }); +}); + +test('forEach calls iterator with correct this value', function (t) { + var thisValue = {}; + + t.plan(1); + + forEach([0], function () { + t.equal(this, thisValue); + }, thisValue); +}); + +test('second argument: iterator', function (t) { + /** @type {unknown[]} */ + var arr = []; + + // @ts-expect-error + t['throws'](function () { forEach(arr); }, TypeError, 'undefined is not a function'); + // @ts-expect-error + t['throws'](function () { forEach(arr, null); }, TypeError, 'null is not a function'); + // @ts-expect-error + t['throws'](function () { forEach(arr, ''); }, TypeError, 'string is not a function'); + // @ts-expect-error + t['throws'](function () { forEach(arr, /a/); }, TypeError, 'regex is not a function'); + // @ts-expect-error + t['throws'](function () { forEach(arr, true); }, TypeError, 'true is not a function'); + // @ts-expect-error + t['throws'](function () { forEach(arr, false); }, TypeError, 'false is not a function'); + // @ts-expect-error + t['throws'](function () { forEach(arr, NaN); }, TypeError, 'NaN is not a function'); + // @ts-expect-error + t['throws'](function () { forEach(arr, 42); }, TypeError, '42 is not a function'); + + t.doesNotThrow(function () { forEach(arr, function () {}); }, 'function is a function'); + // @ts-expect-error TODO fixme + t.doesNotThrow(function () { forEach(arr, setTimeout); }, 'setTimeout is a function'); + + /* eslint-env browser */ + if (typeof window !== 'undefined') { + t.doesNotThrow(function () { forEach(arr, window.alert); }, 'alert is a function'); + } + + t.end(); +}); + +test('array', function (t) { + var arr = /** @type {const} */ ([1, 2, 3]); + + t.test('iterates over every item', function (st) { + var index = 0; + forEach(arr, function () { index += 1; }); + st.equal(index, arr.length, 'iterates ' + arr.length + ' times'); + st.end(); + }); + + t.test('first iterator argument', function (st) { + var index = 0; + st.plan(arr.length); + + forEach(arr, function (item) { + st.equal(arr[index], item, 'item ' + index + ' is passed as first argument'); + index += 1; + }); + + st.end(); + }); + + t.test('second iterator argument', function (st) { + var counter = 0; + st.plan(arr.length); + + forEach(arr, function (_item, index) { + st.equal(counter, index, 'index ' + index + ' is passed as second argument'); + counter += 1; + }); + + st.end(); + }); + + t.test('third iterator argument', function (st) { + st.plan(arr.length); + + forEach(arr, function (_item, _index, array) { + st.deepEqual(arr, array, 'array is passed as third argument'); + }); + + st.end(); + }); + + t.test('context argument', function (st) { + var context = {}; + + forEach([], function () { + st.equal(this, context, '"this" is the passed context'); + }, context); + + st.end(); + }); + + t.end(); +}); + +test('object', function (t) { + var obj = { + a: 1, + b: 2, + c: 3 + }; + var keys = /** @type {const} */ (['a', 'b', 'c']); + + /** @constructor */ + function F() { + this.a = 1; + this.b = 2; + } + F.prototype.c = 3; + var fKeys = /** @type {const} */ (['a', 'b']); + + t.test('iterates over every object literal key', function (st) { + var counter = 0; + + forEach(obj, function () { counter += 1; }); + + st.equal(counter, keys.length, 'iterated ' + counter + ' times'); + + st.end(); + }); + + t.test('iterates only over own keys', function (st) { + var counter = 0; + + forEach(new F(), function () { counter += 1; }); + + st.equal(counter, fKeys.length, 'iterated ' + fKeys.length + ' times'); + + st.end(); + }); + + t.test('first iterator argument', function (st) { + var index = 0; + st.plan(keys.length); + + forEach(obj, function (item) { + st.equal(obj[keys[index]], item, 'item at key ' + keys[index] + ' is passed as first argument'); + index += 1; + }); + + st.end(); + }); + + t.test('second iterator argument', function (st) { + var counter = 0; + st.plan(keys.length); + + forEach(obj, function (_item, key) { + st.equal(keys[counter], key, 'key ' + key + ' is passed as second argument'); + counter += 1; + }); + + st.end(); + }); + + t.test('third iterator argument', function (st) { + st.plan(keys.length); + + forEach(obj, function (_item, _key, object) { + st.deepEqual(obj, object, 'object is passed as third argument'); + }); + + st.end(); + }); + + t.test('context argument', function (st) { + var context = {}; + + forEach({}, function () { + st.equal(this, context, '"this" is the passed context'); + }, context); + + st.end(); + }); + + t.end(); +}); + +test('string', function (t) { + var str = /** @type {const} */ ('str'); + + t.test('second iterator argument', function (st) { + var counter = 0; + st.plan((str.length * 2) + 1); + + forEach(str, function (item, index) { + st.equal(counter, index, 'index ' + index + ' is passed as second argument'); + st.equal(str.charAt(index), item); + counter += 1; + }); + + st.equal(counter, str.length, 'iterates ' + str.length + ' times'); + + st.end(); + }); + + t.end(); +}); diff --git a/tools/ui/node_modules/for-each/tsconfig.json b/tools/ui/node_modules/for-each/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..a6aec2c821b73bc8f771c09feb6688a8f9cf3c61 --- /dev/null +++ b/tools/ui/node_modules/for-each/tsconfig.json @@ -0,0 +1,8 @@ +{ + "extends": "@ljharb/tsconfig", + "compilerOptions": { + }, + "exclude": [ + "coverage", + ], +} diff --git a/tools/ui/node_modules/foreground-child/LICENSE b/tools/ui/node_modules/foreground-child/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..2d80720fe669c96dd0cfec56a90939666086e701 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/LICENSE @@ -0,0 +1,15 @@ +The ISC License + +Copyright (c) 2015-2023 Isaac Z. Schlueter and Contributors + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/tools/ui/node_modules/foreground-child/README.md b/tools/ui/node_modules/foreground-child/README.md new file mode 100644 index 0000000000000000000000000000000000000000..477ca57178e39045cd30a5d83f40b02632d95b35 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/README.md @@ -0,0 +1,128 @@ +# foreground-child + +Run a child as if it's the foreground process. Give it stdio. Exit +when it exits. + +Mostly this module is here to support some use cases around +wrapping child processes for test coverage and such. But it's +also generally useful any time you want one program to execute +another as if it's the "main" process, for example, if a program +takes a `--cmd` argument to execute in some way. + +## USAGE + +```js +import { foregroundChild } from 'foreground-child' +// hybrid module, this also works: +// const { foregroundChild } = require('foreground-child') + +// cats out this file +const child = foregroundChild('cat', [__filename]) + +// At this point, it's best to just do nothing else. +// return or whatever. +// If the child gets a signal, or just exits, then this +// parent process will exit in the same way. +``` + +You can provide custom spawn options by passing an object after +the program and arguments: + +```js +const child = foregroundChild(`cat ${__filename}`, { shell: true }) +``` + +A callback can optionally be provided, if you want to perform an +action before your foreground-child exits: + +```js +const child = foregroundChild('cat', [__filename], spawnOptions, () => { + doSomeActions() +}) +``` + +The callback can return a Promise in order to perform +asynchronous actions. If the callback does not return a promise, +then it must complete its actions within a single JavaScript +tick. + +```js +const child = foregroundChild('cat', [__filename], async () => { + await doSomeAsyncActions() +}) +``` + +If the callback throws or rejects, then it will be unhandled, and +node will exit in error. + +If the callback returns a string value, then that will be used as +the signal to exit the parent process. If it returns a number, +then that number will be used as the parent exit status code. If +it returns boolean `false`, then the parent process will not be +terminated. If it returns `undefined`, then it will exit with the +same signal/code as the child process. + +## Caveats + +The "normal" standard IO file descriptors (0, 1, and 2 for stdin, +stdout, and stderr respectively) are shared with the child process. +Additionally, if there is an IPC channel set up in the parent, then +messages are proxied to the child on file descriptor 3. + +In Node, it's possible to also map arbitrary file descriptors +into a child process. In these cases, foreground-child will not +map the file descriptors into the child. If file descriptors 0, +1, or 2 are used for the IPC channel, then strange behavior may +happen (like printing IPC messages to stderr, for example). + +Note that a SIGKILL will always kill the parent process, but +will not proxy the signal to the child process, because SIGKILL +cannot be caught. In order to address this, a special "watchdog" +child process is spawned which will send a SIGKILL to the child +process if it does not terminate within half a second after the +watchdog receives a SIGHUP due to its parent terminating. + +On Windows, issuing a `process.kill(process.pid, signal)` with a +fatal termination signal may cause the process to exit with a `1` +status code rather than reporting the signal properly. This +module tries to do the right thing, but on Windows systems, you +may see that incorrect result. There is as far as I'm aware no +workaround for this. + +## util: `foreground-child/proxy-signals` + +If you just want to proxy the signals to a child process that the +main process receives, you can use the `proxy-signals` export +from this package. + +```js +import { proxySignals } from 'foreground-child/proxy-signals' + +const childProcess = spawn('command', ['some', 'args']) +proxySignals(childProcess) +``` + +Now, any fatal signal received by the current process will be +proxied to the child process. + +It doesn't go in the other direction; ie, signals sent to the +child process will not affect the parent. For that, listen to the +child `exit` or `close` events, and handle them appropriately. + +## util: `foreground-child/watchdog` + +If you are spawning a child process, and want to ensure that it +isn't left dangling if the parent process exits, you can use the +watchdog utility exported by this module. + +```js +import { watchdog } from 'foreground-child/watchdog' + +const childProcess = spawn('command', ['some', 'args']) +const watchdogProcess = watchdog(childProcess) + +// watchdogProcess is a reference to the process monitoring the +// parent and child. There's usually no reason to do anything +// with it, as it's silent and will terminate +// automatically when it's no longer needed. +``` diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.d.ts b/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ecc0a62e044751ab65e55ad71a7ccfe7ec63908f --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.d.ts @@ -0,0 +1,2 @@ +export declare const allSignals: NodeJS.Signals[]; +//# sourceMappingURL=all-signals.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.d.ts.map b/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..cd1c161e1a60f6c933a328a486e7c745a1d440f8 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"all-signals.d.ts","sourceRoot":"","sources":["../../src/all-signals.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,EAShB,MAAM,CAAC,OAAO,EAAE,CAAA"} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.js b/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.js new file mode 100644 index 0000000000000000000000000000000000000000..1692af01e2878914e6174a6cd8dfe4f2f1c713d1 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.js @@ -0,0 +1,58 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.allSignals = void 0; +const node_constants_1 = __importDefault(require("node:constants")); +exports.allSignals = +// this is the full list of signals that Node will let us do anything with +Object.keys(node_constants_1.default).filter(k => k.startsWith('SIG') && + // https://github.com/tapjs/signal-exit/issues/21 + k !== 'SIGPROF' && + // no sense trying to listen for SIGKILL, it's impossible + k !== 'SIGKILL'); +// These are some obscure signals that are reported by kill -l +// on macOS, Linux, or Windows, but which don't have any mapping +// in Node.js. No sense trying if they're just going to throw +// every time on every platform. +// +// 'SIGEMT', +// 'SIGLOST', +// 'SIGPOLL', +// 'SIGRTMAX', +// 'SIGRTMAX-1', +// 'SIGRTMAX-10', +// 'SIGRTMAX-11', +// 'SIGRTMAX-12', +// 'SIGRTMAX-13', +// 'SIGRTMAX-14', +// 'SIGRTMAX-15', +// 'SIGRTMAX-2', +// 'SIGRTMAX-3', +// 'SIGRTMAX-4', +// 'SIGRTMAX-5', +// 'SIGRTMAX-6', +// 'SIGRTMAX-7', +// 'SIGRTMAX-8', +// 'SIGRTMAX-9', +// 'SIGRTMIN', +// 'SIGRTMIN+1', +// 'SIGRTMIN+10', +// 'SIGRTMIN+11', +// 'SIGRTMIN+12', +// 'SIGRTMIN+13', +// 'SIGRTMIN+14', +// 'SIGRTMIN+15', +// 'SIGRTMIN+16', +// 'SIGRTMIN+2', +// 'SIGRTMIN+3', +// 'SIGRTMIN+4', +// 'SIGRTMIN+5', +// 'SIGRTMIN+6', +// 'SIGRTMIN+7', +// 'SIGRTMIN+8', +// 'SIGRTMIN+9', +// 'SIGSTKFLT', +// 'SIGUNUSED', +//# sourceMappingURL=all-signals.js.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.js.map b/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.js.map new file mode 100644 index 0000000000000000000000000000000000000000..51c056d7079582e9c5fe6a4253fd01b6da3ecad3 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/all-signals.js.map @@ -0,0 +1 @@ +{"version":3,"file":"all-signals.js","sourceRoot":"","sources":["../../src/all-signals.ts"],"names":[],"mappings":";;;;;;AAAA,oEAAsC;AACzB,QAAA,UAAU;AACrB,0EAA0E;AAC1E,MAAM,CAAC,IAAI,CAAC,wBAAS,CAAC,CAAC,MAAM,CAC3B,CAAC,CAAC,EAAE,CACF,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC;IACnB,iDAAiD;IACjD,CAAC,KAAK,SAAS;IACf,yDAAyD;IACzD,CAAC,KAAK,SAAS,CACE,CAAA;AAEvB,8DAA8D;AAC9D,gEAAgE;AAChE,6DAA6D;AAC7D,gCAAgC;AAChC,EAAE;AACF,YAAY;AACZ,aAAa;AACb,aAAa;AACb,cAAc;AACd,gBAAgB;AAChB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,cAAc;AACd,gBAAgB;AAChB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,eAAe;AACf,eAAe","sourcesContent":["import constants from 'node:constants'\nexport const allSignals =\n // this is the full list of signals that Node will let us do anything with\n Object.keys(constants).filter(\n k =>\n k.startsWith('SIG') &&\n // https://github.com/tapjs/signal-exit/issues/21\n k !== 'SIGPROF' &&\n // no sense trying to listen for SIGKILL, it's impossible\n k !== 'SIGKILL',\n ) as NodeJS.Signals[]\n\n// These are some obscure signals that are reported by kill -l\n// on macOS, Linux, or Windows, but which don't have any mapping\n// in Node.js. No sense trying if they're just going to throw\n// every time on every platform.\n//\n// 'SIGEMT',\n// 'SIGLOST',\n// 'SIGPOLL',\n// 'SIGRTMAX',\n// 'SIGRTMAX-1',\n// 'SIGRTMAX-10',\n// 'SIGRTMAX-11',\n// 'SIGRTMAX-12',\n// 'SIGRTMAX-13',\n// 'SIGRTMAX-14',\n// 'SIGRTMAX-15',\n// 'SIGRTMAX-2',\n// 'SIGRTMAX-3',\n// 'SIGRTMAX-4',\n// 'SIGRTMAX-5',\n// 'SIGRTMAX-6',\n// 'SIGRTMAX-7',\n// 'SIGRTMAX-8',\n// 'SIGRTMAX-9',\n// 'SIGRTMIN',\n// 'SIGRTMIN+1',\n// 'SIGRTMIN+10',\n// 'SIGRTMIN+11',\n// 'SIGRTMIN+12',\n// 'SIGRTMIN+13',\n// 'SIGRTMIN+14',\n// 'SIGRTMIN+15',\n// 'SIGRTMIN+16',\n// 'SIGRTMIN+2',\n// 'SIGRTMIN+3',\n// 'SIGRTMIN+4',\n// 'SIGRTMIN+5',\n// 'SIGRTMIN+6',\n// 'SIGRTMIN+7',\n// 'SIGRTMIN+8',\n// 'SIGRTMIN+9',\n// 'SIGSTKFLT',\n// 'SIGUNUSED',\n"]} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/index.d.ts b/tools/ui/node_modules/foreground-child/dist/commonjs/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d15b38e51e71b05d60a37b3f208989a2f850abf6 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/index.d.ts @@ -0,0 +1,58 @@ +import { ChildProcessByStdio, SpawnOptions, ChildProcess } from 'child_process'; +/** + * The signature for the cleanup method. + * + * Arguments indicate the exit status of the child process. + * + * If a Promise is returned, then the process is not terminated + * until it resolves, and the resolution value is treated as the + * exit status (if a number) or signal exit (if a signal string). + * + * If `undefined` is returned, then no change is made, and the parent + * exits in the same way that the child exited. + * + * If boolean `false` is returned, then the parent's exit is canceled. + * + * If a number is returned, then the parent process exits with the number + * as its exitCode. + * + * If a signal string is returned, then the parent process is killed with + * the same signal that caused the child to exit. + */ +export type Cleanup = (code: number | null, signal: null | NodeJS.Signals, processInfo: { + watchdogPid?: ChildProcess['pid']; +}) => void | undefined | number | NodeJS.Signals | false | Promise; +export type FgArgs = [program: string | [cmd: string, ...args: string[]], cleanup?: Cleanup] | [ + program: [cmd: string, ...args: string[]], + opts?: SpawnOptions, + cleanup?: Cleanup +] | [program: string, cleanup?: Cleanup] | [program: string, opts?: SpawnOptions, cleanup?: Cleanup] | [program: string, args?: string[], cleanup?: Cleanup] | [ + program: string, + args?: string[], + opts?: SpawnOptions, + cleanup?: Cleanup +]; +/** + * Normalizes the arguments passed to `foregroundChild`. + * + * Exposed for testing. + * + * @internal + */ +export declare const normalizeFgArgs: (fgArgs: FgArgs) => [program: string, args: string[], spawnOpts: SpawnOptions, cleanup: Cleanup]; +/** + * Spawn the specified program as a "foreground" process, or at least as + * close as is possible given node's lack of exec-without-fork. + * + * Cleanup method may be used to modify or ignore the result of the child's + * exit code or signal. If cleanup returns undefined (or a Promise that + * resolves to undefined), then the parent will exit in the same way that + * the child did. + * + * Return boolean `false` to prevent the parent's exit entirely. + */ +export declare function foregroundChild(cmd: string | [cmd: string, ...args: string[]], cleanup?: Cleanup): ChildProcessByStdio; +export declare function foregroundChild(program: string, args?: string[], cleanup?: Cleanup): ChildProcessByStdio; +export declare function foregroundChild(program: string, spawnOpts?: SpawnOptions, cleanup?: Cleanup): ChildProcessByStdio; +export declare function foregroundChild(program: string, args?: string[], spawnOpts?: SpawnOptions, cleanup?: Cleanup): ChildProcessByStdio; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/index.d.ts.map b/tools/ui/node_modules/foreground-child/dist/commonjs/index.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..b26fecdd4cec719f4a067a894dcbf7d38f72e579 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EAInB,YAAY,EACZ,YAAY,EACb,MAAM,eAAe,CAAA;AAUtB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,OAAO,GAAG,CACpB,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC,OAAO,EAC7B,WAAW,EAAE;IACX,WAAW,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,CAAA;CAClC,KAEC,IAAI,GACJ,SAAS,GACT,MAAM,GACN,MAAM,CAAC,OAAO,GACd,KAAK,GACL,OAAO,CAAC,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC,CAAA;AAE/D,MAAM,MAAM,MAAM,GACd,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GACvE;IACE,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC;IACzC,IAAI,CAAC,EAAE,YAAY;IACnB,OAAO,CAAC,EAAE,OAAO;CAClB,GACD,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GACpC,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GACzD,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GACrD;IACE,OAAO,EAAE,MAAM;IACf,IAAI,CAAC,EAAE,MAAM,EAAE;IACf,IAAI,CAAC,EAAE,YAAY;IACnB,OAAO,CAAC,EAAE,OAAO;CAClB,CAAA;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,WAClB,MAAM,KACb,CACD,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,SAAS,EAAE,YAAY,EACvB,OAAO,EAAE,OAAO,CAqBjB,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC,EAC9C,OAAO,CAAC,EAAE,OAAO,GAChB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AACxC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,OAAO,CAAC,EAAE,OAAO,GAChB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AACxC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,YAAY,EACxB,OAAO,CAAC,EAAE,OAAO,GAChB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AACxC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,SAAS,CAAC,EAAE,YAAY,EACxB,OAAO,CAAC,EAAE,OAAO,GAChB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/index.js b/tools/ui/node_modules/foreground-child/dist/commonjs/index.js new file mode 100644 index 0000000000000000000000000000000000000000..6db65c65dca62d2e3072b3fe5b1ec07ceaf64cf7 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/index.js @@ -0,0 +1,123 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.normalizeFgArgs = void 0; +exports.foregroundChild = foregroundChild; +const child_process_1 = require("child_process"); +const cross_spawn_1 = __importDefault(require("cross-spawn")); +const signal_exit_1 = require("signal-exit"); +const proxy_signals_js_1 = require("./proxy-signals.js"); +const watchdog_js_1 = require("./watchdog.js"); +/* c8 ignore start */ +const spawn = process?.platform === 'win32' ? cross_spawn_1.default : child_process_1.spawn; +/** + * Normalizes the arguments passed to `foregroundChild`. + * + * Exposed for testing. + * + * @internal + */ +const normalizeFgArgs = (fgArgs) => { + let [program, args = [], spawnOpts = {}, cleanup = () => { }] = fgArgs; + if (typeof args === 'function') { + cleanup = args; + spawnOpts = {}; + args = []; + } + else if (!!args && typeof args === 'object' && !Array.isArray(args)) { + if (typeof spawnOpts === 'function') + cleanup = spawnOpts; + spawnOpts = args; + args = []; + } + else if (typeof spawnOpts === 'function') { + cleanup = spawnOpts; + spawnOpts = {}; + } + if (Array.isArray(program)) { + const [pp, ...pa] = program; + program = pp; + args = pa; + } + return [program, args, { ...spawnOpts }, cleanup]; +}; +exports.normalizeFgArgs = normalizeFgArgs; +function foregroundChild(...fgArgs) { + const [program, args, spawnOpts, cleanup] = (0, exports.normalizeFgArgs)(fgArgs); + spawnOpts.stdio = [0, 1, 2]; + if (process.send) { + spawnOpts.stdio.push('ipc'); + } + const child = spawn(program, args, spawnOpts); + const childHangup = () => { + try { + child.kill('SIGHUP'); + /* c8 ignore start */ + } + catch (_) { + // SIGHUP is weird on windows + child.kill('SIGTERM'); + } + /* c8 ignore stop */ + }; + const removeOnExit = (0, signal_exit_1.onExit)(childHangup); + (0, proxy_signals_js_1.proxySignals)(child); + const dog = (0, watchdog_js_1.watchdog)(child); + let done = false; + child.on('close', async (code, signal) => { + /* c8 ignore start */ + if (done) + return; + /* c8 ignore stop */ + done = true; + const result = cleanup(code, signal, { + watchdogPid: dog.pid, + }); + const res = isPromise(result) ? await result : result; + removeOnExit(); + if (res === false) + return; + else if (typeof res === 'string') { + signal = res; + code = null; + } + else if (typeof res === 'number') { + code = res; + signal = null; + } + if (signal) { + // If there is nothing else keeping the event loop alive, + // then there's a race between a graceful exit and getting + // the signal to this process. Put this timeout here to + // make sure we're still alive to get the signal, and thus + // exit with the intended signal code. + /* istanbul ignore next */ + setTimeout(() => { }, 2000); + try { + process.kill(process.pid, signal); + /* c8 ignore start */ + } + catch (_) { + process.kill(process.pid, 'SIGTERM'); + } + /* c8 ignore stop */ + } + else { + process.exit(code || 0); + } + }); + if (process.send) { + process.removeAllListeners('message'); + child.on('message', (message, sendHandle) => { + process.send?.(message, sendHandle); + }); + process.on('message', (message, sendHandle) => { + child.send(message, sendHandle); + }); + } + return child; +} +const isPromise = (o) => !!o && typeof o === 'object' && typeof o.then === 'function'; +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/index.js.map b/tools/ui/node_modules/foreground-child/dist/commonjs/index.js.map new file mode 100644 index 0000000000000000000000000000000000000000..56037c846660b1710f148995a4d591b309984748 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;AAuIA,0CAyFC;AAhOD,iDAOsB;AACtB,8DAAoC;AACpC,6CAAoC;AACpC,yDAAiD;AACjD,+CAAwC;AAExC,qBAAqB;AACrB,MAAM,KAAK,GAAG,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,qBAAU,CAAC,CAAC,CAAC,qBAAS,CAAA;AAsDpE;;;;;;GAMG;AACI,MAAM,eAAe,GAAG,CAC7B,MAAc,EAMd,EAAE;IACF,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,EAAE,EAAE,SAAS,GAAG,EAAE,EAAE,OAAO,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC,GAAG,MAAM,CAAA;IACrE,IAAI,OAAO,IAAI,KAAK,UAAU,EAAE,CAAC;QAC/B,OAAO,GAAG,IAAI,CAAA;QACd,SAAS,GAAG,EAAE,CAAA;QACd,IAAI,GAAG,EAAE,CAAA;IACX,CAAC;SAAM,IAAI,CAAC,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACtE,IAAI,OAAO,SAAS,KAAK,UAAU;YAAE,OAAO,GAAG,SAAS,CAAA;QACxD,SAAS,GAAG,IAAI,CAAA;QAChB,IAAI,GAAG,EAAE,CAAA;IACX,CAAC;SAAM,IAAI,OAAO,SAAS,KAAK,UAAU,EAAE,CAAC;QAC3C,OAAO,GAAG,SAAS,CAAA;QACnB,SAAS,GAAG,EAAE,CAAA;IAChB,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3B,MAAM,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAA;QAC3B,OAAO,GAAG,EAAE,CAAA;QACZ,IAAI,GAAG,EAAE,CAAA;IACX,CAAC;IACD,OAAO,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,GAAG,SAAS,EAAE,EAAE,OAAO,CAAC,CAAA;AACnD,CAAC,CAAA;AA3BY,QAAA,eAAe,mBA2B3B;AAiCD,SAAgB,eAAe,CAC7B,GAAG,MAAc;IAEjB,MAAM,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,GAAG,IAAA,uBAAe,EAAC,MAAM,CAAC,CAAA;IAEnE,SAAS,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IAC3B,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QACjB,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAC7B,CAAC;IAED,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,CAI3C,CAAA;IAED,MAAM,WAAW,GAAG,GAAG,EAAE;QACvB,IAAI,CAAC;YACH,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YAEpB,qBAAqB;QACvB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,6BAA6B;YAC7B,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACvB,CAAC;QACD,oBAAoB;IACtB,CAAC,CAAA;IACD,MAAM,YAAY,GAAG,IAAA,oBAAM,EAAC,WAAW,CAAC,CAAA;IAExC,IAAA,+BAAY,EAAC,KAAK,CAAC,CAAA;IACnB,MAAM,GAAG,GAAG,IAAA,sBAAQ,EAAC,KAAK,CAAC,CAAA;IAE3B,IAAI,IAAI,GAAG,KAAK,CAAA;IAChB,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;QACvC,qBAAqB;QACrB,IAAI,IAAI;YAAE,OAAM;QAChB,oBAAoB;QACpB,IAAI,GAAG,IAAI,CAAA;QACX,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE;YACnC,WAAW,EAAE,GAAG,CAAC,GAAG;SACrB,CAAC,CAAA;QACF,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,MAAM,CAAC,CAAC,CAAC,MAAM,CAAA;QACrD,YAAY,EAAE,CAAA;QAEd,IAAI,GAAG,KAAK,KAAK;YAAE,OAAM;aACpB,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YACjC,MAAM,GAAG,GAAG,CAAA;YACZ,IAAI,GAAG,IAAI,CAAA;QACb,CAAC;aAAM,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YACnC,IAAI,GAAG,GAAG,CAAA;YACV,MAAM,GAAG,IAAI,CAAA;QACf,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,yDAAyD;YACzD,0DAA0D;YAC1D,wDAAwD;YACxD,0DAA0D;YAC1D,sCAAsC;YACtC,0BAA0B;YAC1B,UAAU,CAAC,GAAG,EAAE,GAAE,CAAC,EAAE,IAAI,CAAC,CAAA;YAC1B,IAAI,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;gBACjC,qBAAqB;YACvB,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,SAAS,CAAC,CAAA;YACtC,CAAC;YACD,oBAAoB;QACtB,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAA;QACzB,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QACjB,OAAO,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAA;QAErC,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE;YAC1C,OAAO,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,CAAA;QACrC,CAAC,CAAC,CAAA;QAEF,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE;YAC5C,KAAK,CAAC,IAAI,CACR,OAAuB,EACvB,UAAoC,CACrC,CAAA;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,SAAS,GAAG,CAAC,CAAM,EAAqB,EAAE,CAC9C,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,CAAC,IAAI,KAAK,UAAU,CAAA","sourcesContent":["import {\n ChildProcessByStdio,\n SendHandle,\n Serializable,\n spawn as nodeSpawn,\n SpawnOptions,\n ChildProcess,\n} from 'child_process'\nimport crossSpawn from 'cross-spawn'\nimport { onExit } from 'signal-exit'\nimport { proxySignals } from './proxy-signals.js'\nimport { watchdog } from './watchdog.js'\n\n/* c8 ignore start */\nconst spawn = process?.platform === 'win32' ? crossSpawn : nodeSpawn\n/* c8 ignore stop */\n\n/**\n * The signature for the cleanup method.\n *\n * Arguments indicate the exit status of the child process.\n *\n * If a Promise is returned, then the process is not terminated\n * until it resolves, and the resolution value is treated as the\n * exit status (if a number) or signal exit (if a signal string).\n *\n * If `undefined` is returned, then no change is made, and the parent\n * exits in the same way that the child exited.\n *\n * If boolean `false` is returned, then the parent's exit is canceled.\n *\n * If a number is returned, then the parent process exits with the number\n * as its exitCode.\n *\n * If a signal string is returned, then the parent process is killed with\n * the same signal that caused the child to exit.\n */\nexport type Cleanup = (\n code: number | null,\n signal: null | NodeJS.Signals,\n processInfo: {\n watchdogPid?: ChildProcess['pid']\n },\n) =>\n | void\n | undefined\n | number\n | NodeJS.Signals\n | false\n | Promise\n\nexport type FgArgs =\n | [program: string | [cmd: string, ...args: string[]], cleanup?: Cleanup]\n | [\n program: [cmd: string, ...args: string[]],\n opts?: SpawnOptions,\n cleanup?: Cleanup,\n ]\n | [program: string, cleanup?: Cleanup]\n | [program: string, opts?: SpawnOptions, cleanup?: Cleanup]\n | [program: string, args?: string[], cleanup?: Cleanup]\n | [\n program: string,\n args?: string[],\n opts?: SpawnOptions,\n cleanup?: Cleanup,\n ]\n\n/**\n * Normalizes the arguments passed to `foregroundChild`.\n *\n * Exposed for testing.\n *\n * @internal\n */\nexport const normalizeFgArgs = (\n fgArgs: FgArgs,\n): [\n program: string,\n args: string[],\n spawnOpts: SpawnOptions,\n cleanup: Cleanup,\n] => {\n let [program, args = [], spawnOpts = {}, cleanup = () => {}] = fgArgs\n if (typeof args === 'function') {\n cleanup = args\n spawnOpts = {}\n args = []\n } else if (!!args && typeof args === 'object' && !Array.isArray(args)) {\n if (typeof spawnOpts === 'function') cleanup = spawnOpts\n spawnOpts = args\n args = []\n } else if (typeof spawnOpts === 'function') {\n cleanup = spawnOpts\n spawnOpts = {}\n }\n if (Array.isArray(program)) {\n const [pp, ...pa] = program\n program = pp\n args = pa\n }\n return [program, args, { ...spawnOpts }, cleanup]\n}\n\n/**\n * Spawn the specified program as a \"foreground\" process, or at least as\n * close as is possible given node's lack of exec-without-fork.\n *\n * Cleanup method may be used to modify or ignore the result of the child's\n * exit code or signal. If cleanup returns undefined (or a Promise that\n * resolves to undefined), then the parent will exit in the same way that\n * the child did.\n *\n * Return boolean `false` to prevent the parent's exit entirely.\n */\nexport function foregroundChild(\n cmd: string | [cmd: string, ...args: string[]],\n cleanup?: Cleanup,\n): ChildProcessByStdio\nexport function foregroundChild(\n program: string,\n args?: string[],\n cleanup?: Cleanup,\n): ChildProcessByStdio\nexport function foregroundChild(\n program: string,\n spawnOpts?: SpawnOptions,\n cleanup?: Cleanup,\n): ChildProcessByStdio\nexport function foregroundChild(\n program: string,\n args?: string[],\n spawnOpts?: SpawnOptions,\n cleanup?: Cleanup,\n): ChildProcessByStdio\nexport function foregroundChild(\n ...fgArgs: FgArgs\n): ChildProcessByStdio {\n const [program, args, spawnOpts, cleanup] = normalizeFgArgs(fgArgs)\n\n spawnOpts.stdio = [0, 1, 2]\n if (process.send) {\n spawnOpts.stdio.push('ipc')\n }\n\n const child = spawn(program, args, spawnOpts) as ChildProcessByStdio<\n null,\n null,\n null\n >\n\n const childHangup = () => {\n try {\n child.kill('SIGHUP')\n\n /* c8 ignore start */\n } catch (_) {\n // SIGHUP is weird on windows\n child.kill('SIGTERM')\n }\n /* c8 ignore stop */\n }\n const removeOnExit = onExit(childHangup)\n\n proxySignals(child)\n const dog = watchdog(child)\n\n let done = false\n child.on('close', async (code, signal) => {\n /* c8 ignore start */\n if (done) return\n /* c8 ignore stop */\n done = true\n const result = cleanup(code, signal, {\n watchdogPid: dog.pid,\n })\n const res = isPromise(result) ? await result : result\n removeOnExit()\n\n if (res === false) return\n else if (typeof res === 'string') {\n signal = res\n code = null\n } else if (typeof res === 'number') {\n code = res\n signal = null\n }\n\n if (signal) {\n // If there is nothing else keeping the event loop alive,\n // then there's a race between a graceful exit and getting\n // the signal to this process. Put this timeout here to\n // make sure we're still alive to get the signal, and thus\n // exit with the intended signal code.\n /* istanbul ignore next */\n setTimeout(() => {}, 2000)\n try {\n process.kill(process.pid, signal)\n /* c8 ignore start */\n } catch (_) {\n process.kill(process.pid, 'SIGTERM')\n }\n /* c8 ignore stop */\n } else {\n process.exit(code || 0)\n }\n })\n\n if (process.send) {\n process.removeAllListeners('message')\n\n child.on('message', (message, sendHandle) => {\n process.send?.(message, sendHandle)\n })\n\n process.on('message', (message, sendHandle) => {\n child.send(\n message as Serializable,\n sendHandle as SendHandle | undefined,\n )\n })\n }\n\n return child\n}\n\nconst isPromise = (o: any): o is Promise =>\n !!o && typeof o === 'object' && typeof o.then === 'function'\n"]} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/package.json b/tools/ui/node_modules/foreground-child/dist/commonjs/package.json new file mode 100644 index 0000000000000000000000000000000000000000..5bbefffbabee392d1855491b84dc0a716b6a3bf2 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/package.json @@ -0,0 +1,3 @@ +{ + "type": "commonjs" +} diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.d.ts b/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..edf17bdbf3b04f3bd62f35c6b5ac653dceb767d0 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.d.ts @@ -0,0 +1,6 @@ +import { type ChildProcess } from 'child_process'; +/** + * Starts forwarding signals to `child` through `parent`. + */ +export declare const proxySignals: (child: ChildProcess) => () => void; +//# sourceMappingURL=proxy-signals.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.d.ts.map b/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..7c19279e44b5f4169c7627fd37531cc5ec330a75 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"proxy-signals.d.ts","sourceRoot":"","sources":["../../src/proxy-signals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAA;AAGjD;;GAEG;AACH,eAAO,MAAM,YAAY,UAAW,YAAY,eA4B/C,CAAA"} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.js b/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.js new file mode 100644 index 0000000000000000000000000000000000000000..3913e7b45bce2dcdfba034878a05b3481aa3c7af --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.js @@ -0,0 +1,38 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.proxySignals = void 0; +const all_signals_js_1 = require("./all-signals.js"); +/** + * Starts forwarding signals to `child` through `parent`. + */ +const proxySignals = (child) => { + const listeners = new Map(); + for (const sig of all_signals_js_1.allSignals) { + const listener = () => { + // some signals can only be received, not sent + try { + child.kill(sig); + /* c8 ignore start */ + } + catch (_) { } + /* c8 ignore stop */ + }; + try { + // if it's a signal this system doesn't recognize, skip it + process.on(sig, listener); + listeners.set(sig, listener); + /* c8 ignore start */ + } + catch (_) { } + /* c8 ignore stop */ + } + const unproxy = () => { + for (const [sig, listener] of listeners) { + process.removeListener(sig, listener); + } + }; + child.on('exit', unproxy); + return unproxy; +}; +exports.proxySignals = proxySignals; +//# sourceMappingURL=proxy-signals.js.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.js.map b/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.js.map new file mode 100644 index 0000000000000000000000000000000000000000..199582275685bb1ab7f5a89f5e662229ad8cf995 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/proxy-signals.js.map @@ -0,0 +1 @@ +{"version":3,"file":"proxy-signals.js","sourceRoot":"","sources":["../../src/proxy-signals.ts"],"names":[],"mappings":";;;AACA,qDAA6C;AAE7C;;GAEG;AACI,MAAM,YAAY,GAAG,CAAC,KAAmB,EAAE,EAAE;IAClD,MAAM,SAAS,GAAG,IAAI,GAAG,EAAE,CAAA;IAE3B,KAAK,MAAM,GAAG,IAAI,2BAAU,EAAE,CAAC;QAC7B,MAAM,QAAQ,GAAG,GAAG,EAAE;YACpB,8CAA8C;YAC9C,IAAI,CAAC;gBACH,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;gBACf,qBAAqB;YACvB,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC,CAAA,CAAC;YACd,oBAAoB;QACtB,CAAC,CAAA;QACD,IAAI,CAAC;YACH,0DAA0D;YAC1D,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;YACzB,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;YAC5B,qBAAqB;QACvB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC,CAAA,CAAC;QACd,oBAAoB;IACtB,CAAC;IAED,MAAM,OAAO,GAAG,GAAG,EAAE;QACnB,KAAK,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,SAAS,EAAE,CAAC;YACxC,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;QACvC,CAAC;IACH,CAAC,CAAA;IACD,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACzB,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA;AA5BY,QAAA,YAAY,gBA4BxB","sourcesContent":["import { type ChildProcess } from 'child_process'\nimport { allSignals } from './all-signals.js'\n\n/**\n * Starts forwarding signals to `child` through `parent`.\n */\nexport const proxySignals = (child: ChildProcess) => {\n const listeners = new Map()\n\n for (const sig of allSignals) {\n const listener = () => {\n // some signals can only be received, not sent\n try {\n child.kill(sig)\n /* c8 ignore start */\n } catch (_) {}\n /* c8 ignore stop */\n }\n try {\n // if it's a signal this system doesn't recognize, skip it\n process.on(sig, listener)\n listeners.set(sig, listener)\n /* c8 ignore start */\n } catch (_) {}\n /* c8 ignore stop */\n }\n\n const unproxy = () => {\n for (const [sig, listener] of listeners) {\n process.removeListener(sig, listener)\n }\n }\n child.on('exit', unproxy)\n return unproxy\n}\n"]} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.d.ts b/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f10c9def05ecb1d4f3c9f83c8129647f9852acd6 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.d.ts @@ -0,0 +1,10 @@ +import { ChildProcess } from 'child_process'; +/** + * Pass in a ChildProcess, and this will spawn a watchdog process that + * will make sure it exits if the parent does, thus preventing any + * dangling detached zombie processes. + * + * If the child ends before the parent, then the watchdog will terminate. + */ +export declare const watchdog: (child: ChildProcess) => ChildProcess; +//# sourceMappingURL=watchdog.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.d.ts.map b/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..d9ec2432aa9d4b9b8ffabdf18e7b718a9d78102b --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"watchdog.d.ts","sourceRoot":"","sources":["../../src/watchdog.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAS,MAAM,eAAe,CAAA;AAyBnD;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,UAAW,YAAY,iBAc3C,CAAA"} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.js b/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.js new file mode 100644 index 0000000000000000000000000000000000000000..514e234c2a0edfb42109464891567fb7980ee6d0 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.js @@ -0,0 +1,50 @@ +"use strict"; +// this spawns a child process that listens for SIGHUP when the +// parent process exits, and after 200ms, sends a SIGKILL to the +// child, in case it did not terminate. +Object.defineProperty(exports, "__esModule", { value: true }); +exports.watchdog = void 0; +const child_process_1 = require("child_process"); +const watchdogCode = String.raw ` +const pid = parseInt(process.argv[1], 10) +process.title = 'node (foreground-child watchdog pid=' + pid + ')' +if (!isNaN(pid)) { + let barked = false + // keepalive + const interval = setInterval(() => {}, 60000) + const bark = () => { + clearInterval(interval) + if (barked) return + barked = true + process.removeListener('SIGHUP', bark) + setTimeout(() => { + try { + process.kill(pid, 'SIGKILL') + setTimeout(() => process.exit(), 200) + } catch (_) {} + }, 500) + }) + process.on('SIGHUP', bark) +} +`; +/** + * Pass in a ChildProcess, and this will spawn a watchdog process that + * will make sure it exits if the parent does, thus preventing any + * dangling detached zombie processes. + * + * If the child ends before the parent, then the watchdog will terminate. + */ +const watchdog = (child) => { + let dogExited = false; + const dog = (0, child_process_1.spawn)(process.execPath, ['-e', watchdogCode, String(child.pid)], { + stdio: 'ignore', + }); + dog.on('exit', () => (dogExited = true)); + child.on('exit', () => { + if (!dogExited) + dog.kill('SIGKILL'); + }); + return dog; +}; +exports.watchdog = watchdog; +//# sourceMappingURL=watchdog.js.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.js.map b/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.js.map new file mode 100644 index 0000000000000000000000000000000000000000..d486c97aa83dcb449f681a77a8ae72918fb19058 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/commonjs/watchdog.js.map @@ -0,0 +1 @@ +{"version":3,"file":"watchdog.js","sourceRoot":"","sources":["../../src/watchdog.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,gEAAgE;AAChE,uCAAuC;;;AAEvC,iDAAmD;AAEnD,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;CAqB9B,CAAA;AAED;;;;;;GAMG;AACI,MAAM,QAAQ,GAAG,CAAC,KAAmB,EAAE,EAAE;IAC9C,IAAI,SAAS,GAAG,KAAK,CAAA;IACrB,MAAM,GAAG,GAAG,IAAA,qBAAK,EACf,OAAO,CAAC,QAAQ,EAChB,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EACvC;QACE,KAAK,EAAE,QAAQ;KAChB,CACF,CAAA;IACD,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,CAAA;IACxC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;QACpB,IAAI,CAAC,SAAS;YAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;IACrC,CAAC,CAAC,CAAA;IACF,OAAO,GAAG,CAAA;AACZ,CAAC,CAAA;AAdY,QAAA,QAAQ,YAcpB","sourcesContent":["// this spawns a child process that listens for SIGHUP when the\n// parent process exits, and after 200ms, sends a SIGKILL to the\n// child, in case it did not terminate.\n\nimport { ChildProcess, spawn } from 'child_process'\n\nconst watchdogCode = String.raw`\nconst pid = parseInt(process.argv[1], 10)\nprocess.title = 'node (foreground-child watchdog pid=' + pid + ')'\nif (!isNaN(pid)) {\n let barked = false\n // keepalive\n const interval = setInterval(() => {}, 60000)\n const bark = () => {\n clearInterval(interval)\n if (barked) return\n barked = true\n process.removeListener('SIGHUP', bark)\n setTimeout(() => {\n try {\n process.kill(pid, 'SIGKILL')\n setTimeout(() => process.exit(), 200)\n } catch (_) {}\n }, 500)\n })\n process.on('SIGHUP', bark)\n}\n`\n\n/**\n * Pass in a ChildProcess, and this will spawn a watchdog process that\n * will make sure it exits if the parent does, thus preventing any\n * dangling detached zombie processes.\n *\n * If the child ends before the parent, then the watchdog will terminate.\n */\nexport const watchdog = (child: ChildProcess) => {\n let dogExited = false\n const dog = spawn(\n process.execPath,\n ['-e', watchdogCode, String(child.pid)],\n {\n stdio: 'ignore',\n },\n )\n dog.on('exit', () => (dogExited = true))\n child.on('exit', () => {\n if (!dogExited) dog.kill('SIGKILL')\n })\n return dog\n}\n"]} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/all-signals.d.ts b/tools/ui/node_modules/foreground-child/dist/esm/all-signals.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ecc0a62e044751ab65e55ad71a7ccfe7ec63908f --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/all-signals.d.ts @@ -0,0 +1,2 @@ +export declare const allSignals: NodeJS.Signals[]; +//# sourceMappingURL=all-signals.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/all-signals.d.ts.map b/tools/ui/node_modules/foreground-child/dist/esm/all-signals.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..cd1c161e1a60f6c933a328a486e7c745a1d440f8 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/all-signals.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"all-signals.d.ts","sourceRoot":"","sources":["../../src/all-signals.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,UAAU,EAShB,MAAM,CAAC,OAAO,EAAE,CAAA"} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/all-signals.js b/tools/ui/node_modules/foreground-child/dist/esm/all-signals.js new file mode 100644 index 0000000000000000000000000000000000000000..7e8d54d5cbb2aeab5cc2eef1c552df0de91c6389 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/all-signals.js @@ -0,0 +1,52 @@ +import constants from 'node:constants'; +export const allSignals = +// this is the full list of signals that Node will let us do anything with +Object.keys(constants).filter(k => k.startsWith('SIG') && + // https://github.com/tapjs/signal-exit/issues/21 + k !== 'SIGPROF' && + // no sense trying to listen for SIGKILL, it's impossible + k !== 'SIGKILL'); +// These are some obscure signals that are reported by kill -l +// on macOS, Linux, or Windows, but which don't have any mapping +// in Node.js. No sense trying if they're just going to throw +// every time on every platform. +// +// 'SIGEMT', +// 'SIGLOST', +// 'SIGPOLL', +// 'SIGRTMAX', +// 'SIGRTMAX-1', +// 'SIGRTMAX-10', +// 'SIGRTMAX-11', +// 'SIGRTMAX-12', +// 'SIGRTMAX-13', +// 'SIGRTMAX-14', +// 'SIGRTMAX-15', +// 'SIGRTMAX-2', +// 'SIGRTMAX-3', +// 'SIGRTMAX-4', +// 'SIGRTMAX-5', +// 'SIGRTMAX-6', +// 'SIGRTMAX-7', +// 'SIGRTMAX-8', +// 'SIGRTMAX-9', +// 'SIGRTMIN', +// 'SIGRTMIN+1', +// 'SIGRTMIN+10', +// 'SIGRTMIN+11', +// 'SIGRTMIN+12', +// 'SIGRTMIN+13', +// 'SIGRTMIN+14', +// 'SIGRTMIN+15', +// 'SIGRTMIN+16', +// 'SIGRTMIN+2', +// 'SIGRTMIN+3', +// 'SIGRTMIN+4', +// 'SIGRTMIN+5', +// 'SIGRTMIN+6', +// 'SIGRTMIN+7', +// 'SIGRTMIN+8', +// 'SIGRTMIN+9', +// 'SIGSTKFLT', +// 'SIGUNUSED', +//# sourceMappingURL=all-signals.js.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/all-signals.js.map b/tools/ui/node_modules/foreground-child/dist/esm/all-signals.js.map new file mode 100644 index 0000000000000000000000000000000000000000..1c63c6b9a7052ed6a2ae5e5c8a9394f707f672c1 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/all-signals.js.map @@ -0,0 +1 @@ +{"version":3,"file":"all-signals.js","sourceRoot":"","sources":["../../src/all-signals.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AACtC,MAAM,CAAC,MAAM,UAAU;AACrB,0EAA0E;AAC1E,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,CAC3B,CAAC,CAAC,EAAE,CACF,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC;IACnB,iDAAiD;IACjD,CAAC,KAAK,SAAS;IACf,yDAAyD;IACzD,CAAC,KAAK,SAAS,CACE,CAAA;AAEvB,8DAA8D;AAC9D,gEAAgE;AAChE,6DAA6D;AAC7D,gCAAgC;AAChC,EAAE;AACF,YAAY;AACZ,aAAa;AACb,aAAa;AACb,cAAc;AACd,gBAAgB;AAChB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,cAAc;AACd,gBAAgB;AAChB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,iBAAiB;AACjB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,gBAAgB;AAChB,eAAe;AACf,eAAe","sourcesContent":["import constants from 'node:constants'\nexport const allSignals =\n // this is the full list of signals that Node will let us do anything with\n Object.keys(constants).filter(\n k =>\n k.startsWith('SIG') &&\n // https://github.com/tapjs/signal-exit/issues/21\n k !== 'SIGPROF' &&\n // no sense trying to listen for SIGKILL, it's impossible\n k !== 'SIGKILL',\n ) as NodeJS.Signals[]\n\n// These are some obscure signals that are reported by kill -l\n// on macOS, Linux, or Windows, but which don't have any mapping\n// in Node.js. No sense trying if they're just going to throw\n// every time on every platform.\n//\n// 'SIGEMT',\n// 'SIGLOST',\n// 'SIGPOLL',\n// 'SIGRTMAX',\n// 'SIGRTMAX-1',\n// 'SIGRTMAX-10',\n// 'SIGRTMAX-11',\n// 'SIGRTMAX-12',\n// 'SIGRTMAX-13',\n// 'SIGRTMAX-14',\n// 'SIGRTMAX-15',\n// 'SIGRTMAX-2',\n// 'SIGRTMAX-3',\n// 'SIGRTMAX-4',\n// 'SIGRTMAX-5',\n// 'SIGRTMAX-6',\n// 'SIGRTMAX-7',\n// 'SIGRTMAX-8',\n// 'SIGRTMAX-9',\n// 'SIGRTMIN',\n// 'SIGRTMIN+1',\n// 'SIGRTMIN+10',\n// 'SIGRTMIN+11',\n// 'SIGRTMIN+12',\n// 'SIGRTMIN+13',\n// 'SIGRTMIN+14',\n// 'SIGRTMIN+15',\n// 'SIGRTMIN+16',\n// 'SIGRTMIN+2',\n// 'SIGRTMIN+3',\n// 'SIGRTMIN+4',\n// 'SIGRTMIN+5',\n// 'SIGRTMIN+6',\n// 'SIGRTMIN+7',\n// 'SIGRTMIN+8',\n// 'SIGRTMIN+9',\n// 'SIGSTKFLT',\n// 'SIGUNUSED',\n"]} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/index.d.ts b/tools/ui/node_modules/foreground-child/dist/esm/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..d15b38e51e71b05d60a37b3f208989a2f850abf6 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/index.d.ts @@ -0,0 +1,58 @@ +import { ChildProcessByStdio, SpawnOptions, ChildProcess } from 'child_process'; +/** + * The signature for the cleanup method. + * + * Arguments indicate the exit status of the child process. + * + * If a Promise is returned, then the process is not terminated + * until it resolves, and the resolution value is treated as the + * exit status (if a number) or signal exit (if a signal string). + * + * If `undefined` is returned, then no change is made, and the parent + * exits in the same way that the child exited. + * + * If boolean `false` is returned, then the parent's exit is canceled. + * + * If a number is returned, then the parent process exits with the number + * as its exitCode. + * + * If a signal string is returned, then the parent process is killed with + * the same signal that caused the child to exit. + */ +export type Cleanup = (code: number | null, signal: null | NodeJS.Signals, processInfo: { + watchdogPid?: ChildProcess['pid']; +}) => void | undefined | number | NodeJS.Signals | false | Promise; +export type FgArgs = [program: string | [cmd: string, ...args: string[]], cleanup?: Cleanup] | [ + program: [cmd: string, ...args: string[]], + opts?: SpawnOptions, + cleanup?: Cleanup +] | [program: string, cleanup?: Cleanup] | [program: string, opts?: SpawnOptions, cleanup?: Cleanup] | [program: string, args?: string[], cleanup?: Cleanup] | [ + program: string, + args?: string[], + opts?: SpawnOptions, + cleanup?: Cleanup +]; +/** + * Normalizes the arguments passed to `foregroundChild`. + * + * Exposed for testing. + * + * @internal + */ +export declare const normalizeFgArgs: (fgArgs: FgArgs) => [program: string, args: string[], spawnOpts: SpawnOptions, cleanup: Cleanup]; +/** + * Spawn the specified program as a "foreground" process, or at least as + * close as is possible given node's lack of exec-without-fork. + * + * Cleanup method may be used to modify or ignore the result of the child's + * exit code or signal. If cleanup returns undefined (or a Promise that + * resolves to undefined), then the parent will exit in the same way that + * the child did. + * + * Return boolean `false` to prevent the parent's exit entirely. + */ +export declare function foregroundChild(cmd: string | [cmd: string, ...args: string[]], cleanup?: Cleanup): ChildProcessByStdio; +export declare function foregroundChild(program: string, args?: string[], cleanup?: Cleanup): ChildProcessByStdio; +export declare function foregroundChild(program: string, spawnOpts?: SpawnOptions, cleanup?: Cleanup): ChildProcessByStdio; +export declare function foregroundChild(program: string, args?: string[], spawnOpts?: SpawnOptions, cleanup?: Cleanup): ChildProcessByStdio; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/index.d.ts.map b/tools/ui/node_modules/foreground-child/dist/esm/index.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..b26fecdd4cec719f4a067a894dcbf7d38f72e579 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EAInB,YAAY,EACZ,YAAY,EACb,MAAM,eAAe,CAAA;AAUtB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,OAAO,GAAG,CACpB,IAAI,EAAE,MAAM,GAAG,IAAI,EACnB,MAAM,EAAE,IAAI,GAAG,MAAM,CAAC,OAAO,EAC7B,WAAW,EAAE;IACX,WAAW,CAAC,EAAE,YAAY,CAAC,KAAK,CAAC,CAAA;CAClC,KAEC,IAAI,GACJ,SAAS,GACT,MAAM,GACN,MAAM,CAAC,OAAO,GACd,KAAK,GACL,OAAO,CAAC,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC,CAAA;AAE/D,MAAM,MAAM,MAAM,GACd,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GACvE;IACE,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC;IACzC,IAAI,CAAC,EAAE,YAAY;IACnB,OAAO,CAAC,EAAE,OAAO;CAClB,GACD,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GACpC,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GACzD,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,GACrD;IACE,OAAO,EAAE,MAAM;IACf,IAAI,CAAC,EAAE,MAAM,EAAE;IACf,IAAI,CAAC,EAAE,YAAY;IACnB,OAAO,CAAC,EAAE,OAAO;CAClB,CAAA;AAEL;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,WAClB,MAAM,KACb,CACD,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,SAAS,EAAE,YAAY,EACvB,OAAO,EAAE,OAAO,CAqBjB,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,MAAM,EAAE,CAAC,EAC9C,OAAO,CAAC,EAAE,OAAO,GAChB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AACxC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,OAAO,CAAC,EAAE,OAAO,GAChB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AACxC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,YAAY,EACxB,OAAO,CAAC,EAAE,OAAO,GAChB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AACxC,wBAAgB,eAAe,CAC7B,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,EAAE,EACf,SAAS,CAAC,EAAE,YAAY,EACxB,OAAO,CAAC,EAAE,OAAO,GAChB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/index.js b/tools/ui/node_modules/foreground-child/dist/esm/index.js new file mode 100644 index 0000000000000000000000000000000000000000..6266b5848cceda255c5803c49d7bea5113139f87 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/index.js @@ -0,0 +1,115 @@ +import { spawn as nodeSpawn, } from 'child_process'; +import crossSpawn from 'cross-spawn'; +import { onExit } from 'signal-exit'; +import { proxySignals } from './proxy-signals.js'; +import { watchdog } from './watchdog.js'; +/* c8 ignore start */ +const spawn = process?.platform === 'win32' ? crossSpawn : nodeSpawn; +/** + * Normalizes the arguments passed to `foregroundChild`. + * + * Exposed for testing. + * + * @internal + */ +export const normalizeFgArgs = (fgArgs) => { + let [program, args = [], spawnOpts = {}, cleanup = () => { }] = fgArgs; + if (typeof args === 'function') { + cleanup = args; + spawnOpts = {}; + args = []; + } + else if (!!args && typeof args === 'object' && !Array.isArray(args)) { + if (typeof spawnOpts === 'function') + cleanup = spawnOpts; + spawnOpts = args; + args = []; + } + else if (typeof spawnOpts === 'function') { + cleanup = spawnOpts; + spawnOpts = {}; + } + if (Array.isArray(program)) { + const [pp, ...pa] = program; + program = pp; + args = pa; + } + return [program, args, { ...spawnOpts }, cleanup]; +}; +export function foregroundChild(...fgArgs) { + const [program, args, spawnOpts, cleanup] = normalizeFgArgs(fgArgs); + spawnOpts.stdio = [0, 1, 2]; + if (process.send) { + spawnOpts.stdio.push('ipc'); + } + const child = spawn(program, args, spawnOpts); + const childHangup = () => { + try { + child.kill('SIGHUP'); + /* c8 ignore start */ + } + catch (_) { + // SIGHUP is weird on windows + child.kill('SIGTERM'); + } + /* c8 ignore stop */ + }; + const removeOnExit = onExit(childHangup); + proxySignals(child); + const dog = watchdog(child); + let done = false; + child.on('close', async (code, signal) => { + /* c8 ignore start */ + if (done) + return; + /* c8 ignore stop */ + done = true; + const result = cleanup(code, signal, { + watchdogPid: dog.pid, + }); + const res = isPromise(result) ? await result : result; + removeOnExit(); + if (res === false) + return; + else if (typeof res === 'string') { + signal = res; + code = null; + } + else if (typeof res === 'number') { + code = res; + signal = null; + } + if (signal) { + // If there is nothing else keeping the event loop alive, + // then there's a race between a graceful exit and getting + // the signal to this process. Put this timeout here to + // make sure we're still alive to get the signal, and thus + // exit with the intended signal code. + /* istanbul ignore next */ + setTimeout(() => { }, 2000); + try { + process.kill(process.pid, signal); + /* c8 ignore start */ + } + catch (_) { + process.kill(process.pid, 'SIGTERM'); + } + /* c8 ignore stop */ + } + else { + process.exit(code || 0); + } + }); + if (process.send) { + process.removeAllListeners('message'); + child.on('message', (message, sendHandle) => { + process.send?.(message, sendHandle); + }); + process.on('message', (message, sendHandle) => { + child.send(message, sendHandle); + }); + } + return child; +} +const isPromise = (o) => !!o && typeof o === 'object' && typeof o.then === 'function'; +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/index.js.map b/tools/ui/node_modules/foreground-child/dist/esm/index.js.map new file mode 100644 index 0000000000000000000000000000000000000000..7d9d1bd0e6c3464810b397cefc88de721a0bc9f6 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,IAAI,SAAS,GAGnB,MAAM,eAAe,CAAA;AACtB,OAAO,UAAU,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC,qBAAqB;AACrB,MAAM,KAAK,GAAG,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,SAAS,CAAA;AAsDpE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,MAAc,EAMd,EAAE;IACF,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,EAAE,EAAE,SAAS,GAAG,EAAE,EAAE,OAAO,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC,GAAG,MAAM,CAAA;IACrE,IAAI,OAAO,IAAI,KAAK,UAAU,EAAE,CAAC;QAC/B,OAAO,GAAG,IAAI,CAAA;QACd,SAAS,GAAG,EAAE,CAAA;QACd,IAAI,GAAG,EAAE,CAAA;IACX,CAAC;SAAM,IAAI,CAAC,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QACtE,IAAI,OAAO,SAAS,KAAK,UAAU;YAAE,OAAO,GAAG,SAAS,CAAA;QACxD,SAAS,GAAG,IAAI,CAAA;QAChB,IAAI,GAAG,EAAE,CAAA;IACX,CAAC;SAAM,IAAI,OAAO,SAAS,KAAK,UAAU,EAAE,CAAC;QAC3C,OAAO,GAAG,SAAS,CAAA;QACnB,SAAS,GAAG,EAAE,CAAA;IAChB,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QAC3B,MAAM,CAAC,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAA;QAC3B,OAAO,GAAG,EAAE,CAAA;QACZ,IAAI,GAAG,EAAE,CAAA;IACX,CAAC;IACD,OAAO,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,GAAG,SAAS,EAAE,EAAE,OAAO,CAAC,CAAA;AACnD,CAAC,CAAA;AAiCD,MAAM,UAAU,eAAe,CAC7B,GAAG,MAAc;IAEjB,MAAM,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,GAAG,eAAe,CAAC,MAAM,CAAC,CAAA;IAEnE,SAAS,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAA;IAC3B,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QACjB,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAC7B,CAAC;IAED,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,SAAS,CAI3C,CAAA;IAED,MAAM,WAAW,GAAG,GAAG,EAAE;QACvB,IAAI,CAAC;YACH,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YAEpB,qBAAqB;QACvB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,6BAA6B;YAC7B,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACvB,CAAC;QACD,oBAAoB;IACtB,CAAC,CAAA;IACD,MAAM,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC,CAAA;IAExC,YAAY,CAAC,KAAK,CAAC,CAAA;IACnB,MAAM,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAA;IAE3B,IAAI,IAAI,GAAG,KAAK,CAAA;IAChB,KAAK,CAAC,EAAE,CAAC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;QACvC,qBAAqB;QACrB,IAAI,IAAI;YAAE,OAAM;QAChB,oBAAoB;QACpB,IAAI,GAAG,IAAI,CAAA;QACX,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE;YACnC,WAAW,EAAE,GAAG,CAAC,GAAG;SACrB,CAAC,CAAA;QACF,MAAM,GAAG,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,MAAM,CAAC,CAAC,CAAC,MAAM,CAAA;QACrD,YAAY,EAAE,CAAA;QAEd,IAAI,GAAG,KAAK,KAAK;YAAE,OAAM;aACpB,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YACjC,MAAM,GAAG,GAAG,CAAA;YACZ,IAAI,GAAG,IAAI,CAAA;QACb,CAAC;aAAM,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;YACnC,IAAI,GAAG,GAAG,CAAA;YACV,MAAM,GAAG,IAAI,CAAA;QACf,CAAC;QAED,IAAI,MAAM,EAAE,CAAC;YACX,yDAAyD;YACzD,0DAA0D;YAC1D,wDAAwD;YACxD,0DAA0D;YAC1D,sCAAsC;YACtC,0BAA0B;YAC1B,UAAU,CAAC,GAAG,EAAE,GAAE,CAAC,EAAE,IAAI,CAAC,CAAA;YAC1B,IAAI,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;gBACjC,qBAAqB;YACvB,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,SAAS,CAAC,CAAA;YACtC,CAAC;YACD,oBAAoB;QACtB,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC,CAAA;QACzB,CAAC;IACH,CAAC,CAAC,CAAA;IAEF,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;QACjB,OAAO,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAA;QAErC,KAAK,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE;YAC1C,OAAO,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC,CAAA;QACrC,CAAC,CAAC,CAAA;QAEF,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE;YAC5C,KAAK,CAAC,IAAI,CACR,OAAuB,EACvB,UAAoC,CACrC,CAAA;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,SAAS,GAAG,CAAC,CAAM,EAAqB,EAAE,CAC9C,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,CAAC,IAAI,KAAK,UAAU,CAAA","sourcesContent":["import {\n ChildProcessByStdio,\n SendHandle,\n Serializable,\n spawn as nodeSpawn,\n SpawnOptions,\n ChildProcess,\n} from 'child_process'\nimport crossSpawn from 'cross-spawn'\nimport { onExit } from 'signal-exit'\nimport { proxySignals } from './proxy-signals.js'\nimport { watchdog } from './watchdog.js'\n\n/* c8 ignore start */\nconst spawn = process?.platform === 'win32' ? crossSpawn : nodeSpawn\n/* c8 ignore stop */\n\n/**\n * The signature for the cleanup method.\n *\n * Arguments indicate the exit status of the child process.\n *\n * If a Promise is returned, then the process is not terminated\n * until it resolves, and the resolution value is treated as the\n * exit status (if a number) or signal exit (if a signal string).\n *\n * If `undefined` is returned, then no change is made, and the parent\n * exits in the same way that the child exited.\n *\n * If boolean `false` is returned, then the parent's exit is canceled.\n *\n * If a number is returned, then the parent process exits with the number\n * as its exitCode.\n *\n * If a signal string is returned, then the parent process is killed with\n * the same signal that caused the child to exit.\n */\nexport type Cleanup = (\n code: number | null,\n signal: null | NodeJS.Signals,\n processInfo: {\n watchdogPid?: ChildProcess['pid']\n },\n) =>\n | void\n | undefined\n | number\n | NodeJS.Signals\n | false\n | Promise\n\nexport type FgArgs =\n | [program: string | [cmd: string, ...args: string[]], cleanup?: Cleanup]\n | [\n program: [cmd: string, ...args: string[]],\n opts?: SpawnOptions,\n cleanup?: Cleanup,\n ]\n | [program: string, cleanup?: Cleanup]\n | [program: string, opts?: SpawnOptions, cleanup?: Cleanup]\n | [program: string, args?: string[], cleanup?: Cleanup]\n | [\n program: string,\n args?: string[],\n opts?: SpawnOptions,\n cleanup?: Cleanup,\n ]\n\n/**\n * Normalizes the arguments passed to `foregroundChild`.\n *\n * Exposed for testing.\n *\n * @internal\n */\nexport const normalizeFgArgs = (\n fgArgs: FgArgs,\n): [\n program: string,\n args: string[],\n spawnOpts: SpawnOptions,\n cleanup: Cleanup,\n] => {\n let [program, args = [], spawnOpts = {}, cleanup = () => {}] = fgArgs\n if (typeof args === 'function') {\n cleanup = args\n spawnOpts = {}\n args = []\n } else if (!!args && typeof args === 'object' && !Array.isArray(args)) {\n if (typeof spawnOpts === 'function') cleanup = spawnOpts\n spawnOpts = args\n args = []\n } else if (typeof spawnOpts === 'function') {\n cleanup = spawnOpts\n spawnOpts = {}\n }\n if (Array.isArray(program)) {\n const [pp, ...pa] = program\n program = pp\n args = pa\n }\n return [program, args, { ...spawnOpts }, cleanup]\n}\n\n/**\n * Spawn the specified program as a \"foreground\" process, or at least as\n * close as is possible given node's lack of exec-without-fork.\n *\n * Cleanup method may be used to modify or ignore the result of the child's\n * exit code or signal. If cleanup returns undefined (or a Promise that\n * resolves to undefined), then the parent will exit in the same way that\n * the child did.\n *\n * Return boolean `false` to prevent the parent's exit entirely.\n */\nexport function foregroundChild(\n cmd: string | [cmd: string, ...args: string[]],\n cleanup?: Cleanup,\n): ChildProcessByStdio\nexport function foregroundChild(\n program: string,\n args?: string[],\n cleanup?: Cleanup,\n): ChildProcessByStdio\nexport function foregroundChild(\n program: string,\n spawnOpts?: SpawnOptions,\n cleanup?: Cleanup,\n): ChildProcessByStdio\nexport function foregroundChild(\n program: string,\n args?: string[],\n spawnOpts?: SpawnOptions,\n cleanup?: Cleanup,\n): ChildProcessByStdio\nexport function foregroundChild(\n ...fgArgs: FgArgs\n): ChildProcessByStdio {\n const [program, args, spawnOpts, cleanup] = normalizeFgArgs(fgArgs)\n\n spawnOpts.stdio = [0, 1, 2]\n if (process.send) {\n spawnOpts.stdio.push('ipc')\n }\n\n const child = spawn(program, args, spawnOpts) as ChildProcessByStdio<\n null,\n null,\n null\n >\n\n const childHangup = () => {\n try {\n child.kill('SIGHUP')\n\n /* c8 ignore start */\n } catch (_) {\n // SIGHUP is weird on windows\n child.kill('SIGTERM')\n }\n /* c8 ignore stop */\n }\n const removeOnExit = onExit(childHangup)\n\n proxySignals(child)\n const dog = watchdog(child)\n\n let done = false\n child.on('close', async (code, signal) => {\n /* c8 ignore start */\n if (done) return\n /* c8 ignore stop */\n done = true\n const result = cleanup(code, signal, {\n watchdogPid: dog.pid,\n })\n const res = isPromise(result) ? await result : result\n removeOnExit()\n\n if (res === false) return\n else if (typeof res === 'string') {\n signal = res\n code = null\n } else if (typeof res === 'number') {\n code = res\n signal = null\n }\n\n if (signal) {\n // If there is nothing else keeping the event loop alive,\n // then there's a race between a graceful exit and getting\n // the signal to this process. Put this timeout here to\n // make sure we're still alive to get the signal, and thus\n // exit with the intended signal code.\n /* istanbul ignore next */\n setTimeout(() => {}, 2000)\n try {\n process.kill(process.pid, signal)\n /* c8 ignore start */\n } catch (_) {\n process.kill(process.pid, 'SIGTERM')\n }\n /* c8 ignore stop */\n } else {\n process.exit(code || 0)\n }\n })\n\n if (process.send) {\n process.removeAllListeners('message')\n\n child.on('message', (message, sendHandle) => {\n process.send?.(message, sendHandle)\n })\n\n process.on('message', (message, sendHandle) => {\n child.send(\n message as Serializable,\n sendHandle as SendHandle | undefined,\n )\n })\n }\n\n return child\n}\n\nconst isPromise = (o: any): o is Promise =>\n !!o && typeof o === 'object' && typeof o.then === 'function'\n"]} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/package.json b/tools/ui/node_modules/foreground-child/dist/esm/package.json new file mode 100644 index 0000000000000000000000000000000000000000..3dbc1ca591c0557e35b6004aeba250e6a70b56e3 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/package.json @@ -0,0 +1,3 @@ +{ + "type": "module" +} diff --git a/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.d.ts b/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..edf17bdbf3b04f3bd62f35c6b5ac653dceb767d0 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.d.ts @@ -0,0 +1,6 @@ +import { type ChildProcess } from 'child_process'; +/** + * Starts forwarding signals to `child` through `parent`. + */ +export declare const proxySignals: (child: ChildProcess) => () => void; +//# sourceMappingURL=proxy-signals.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.d.ts.map b/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..7c19279e44b5f4169c7627fd37531cc5ec330a75 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"proxy-signals.d.ts","sourceRoot":"","sources":["../../src/proxy-signals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAA;AAGjD;;GAEG;AACH,eAAO,MAAM,YAAY,UAAW,YAAY,eA4B/C,CAAA"} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.js b/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.js new file mode 100644 index 0000000000000000000000000000000000000000..8e1efe3e301d66236a6b5e6c795a9f43872a669f --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.js @@ -0,0 +1,34 @@ +import { allSignals } from './all-signals.js'; +/** + * Starts forwarding signals to `child` through `parent`. + */ +export const proxySignals = (child) => { + const listeners = new Map(); + for (const sig of allSignals) { + const listener = () => { + // some signals can only be received, not sent + try { + child.kill(sig); + /* c8 ignore start */ + } + catch (_) { } + /* c8 ignore stop */ + }; + try { + // if it's a signal this system doesn't recognize, skip it + process.on(sig, listener); + listeners.set(sig, listener); + /* c8 ignore start */ + } + catch (_) { } + /* c8 ignore stop */ + } + const unproxy = () => { + for (const [sig, listener] of listeners) { + process.removeListener(sig, listener); + } + }; + child.on('exit', unproxy); + return unproxy; +}; +//# sourceMappingURL=proxy-signals.js.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.js.map b/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.js.map new file mode 100644 index 0000000000000000000000000000000000000000..978750fcc5a57cf4a81449ea6f60e0ed3a958144 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/proxy-signals.js.map @@ -0,0 +1 @@ +{"version":3,"file":"proxy-signals.js","sourceRoot":"","sources":["../../src/proxy-signals.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE7C;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,KAAmB,EAAE,EAAE;IAClD,MAAM,SAAS,GAAG,IAAI,GAAG,EAAE,CAAA;IAE3B,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;QAC7B,MAAM,QAAQ,GAAG,GAAG,EAAE;YACpB,8CAA8C;YAC9C,IAAI,CAAC;gBACH,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;gBACf,qBAAqB;YACvB,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC,CAAA,CAAC;YACd,oBAAoB;QACtB,CAAC,CAAA;QACD,IAAI,CAAC;YACH,0DAA0D;YAC1D,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;YACzB,SAAS,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;YAC5B,qBAAqB;QACvB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC,CAAA,CAAC;QACd,oBAAoB;IACtB,CAAC;IAED,MAAM,OAAO,GAAG,GAAG,EAAE;QACnB,KAAK,MAAM,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,SAAS,EAAE,CAAC;YACxC,OAAO,CAAC,cAAc,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAA;QACvC,CAAC;IACH,CAAC,CAAA;IACD,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACzB,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA","sourcesContent":["import { type ChildProcess } from 'child_process'\nimport { allSignals } from './all-signals.js'\n\n/**\n * Starts forwarding signals to `child` through `parent`.\n */\nexport const proxySignals = (child: ChildProcess) => {\n const listeners = new Map()\n\n for (const sig of allSignals) {\n const listener = () => {\n // some signals can only be received, not sent\n try {\n child.kill(sig)\n /* c8 ignore start */\n } catch (_) {}\n /* c8 ignore stop */\n }\n try {\n // if it's a signal this system doesn't recognize, skip it\n process.on(sig, listener)\n listeners.set(sig, listener)\n /* c8 ignore start */\n } catch (_) {}\n /* c8 ignore stop */\n }\n\n const unproxy = () => {\n for (const [sig, listener] of listeners) {\n process.removeListener(sig, listener)\n }\n }\n child.on('exit', unproxy)\n return unproxy\n}\n"]} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/watchdog.d.ts b/tools/ui/node_modules/foreground-child/dist/esm/watchdog.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f10c9def05ecb1d4f3c9f83c8129647f9852acd6 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/watchdog.d.ts @@ -0,0 +1,10 @@ +import { ChildProcess } from 'child_process'; +/** + * Pass in a ChildProcess, and this will spawn a watchdog process that + * will make sure it exits if the parent does, thus preventing any + * dangling detached zombie processes. + * + * If the child ends before the parent, then the watchdog will terminate. + */ +export declare const watchdog: (child: ChildProcess) => ChildProcess; +//# sourceMappingURL=watchdog.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/watchdog.d.ts.map b/tools/ui/node_modules/foreground-child/dist/esm/watchdog.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..d9ec2432aa9d4b9b8ffabdf18e7b718a9d78102b --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/watchdog.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"watchdog.d.ts","sourceRoot":"","sources":["../../src/watchdog.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAS,MAAM,eAAe,CAAA;AAyBnD;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,UAAW,YAAY,iBAc3C,CAAA"} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/watchdog.js b/tools/ui/node_modules/foreground-child/dist/esm/watchdog.js new file mode 100644 index 0000000000000000000000000000000000000000..7aa184ede4f5a0e95243adcf24e037bf86a58f78 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/watchdog.js @@ -0,0 +1,46 @@ +// this spawns a child process that listens for SIGHUP when the +// parent process exits, and after 200ms, sends a SIGKILL to the +// child, in case it did not terminate. +import { spawn } from 'child_process'; +const watchdogCode = String.raw ` +const pid = parseInt(process.argv[1], 10) +process.title = 'node (foreground-child watchdog pid=' + pid + ')' +if (!isNaN(pid)) { + let barked = false + // keepalive + const interval = setInterval(() => {}, 60000) + const bark = () => { + clearInterval(interval) + if (barked) return + barked = true + process.removeListener('SIGHUP', bark) + setTimeout(() => { + try { + process.kill(pid, 'SIGKILL') + setTimeout(() => process.exit(), 200) + } catch (_) {} + }, 500) + }) + process.on('SIGHUP', bark) +} +`; +/** + * Pass in a ChildProcess, and this will spawn a watchdog process that + * will make sure it exits if the parent does, thus preventing any + * dangling detached zombie processes. + * + * If the child ends before the parent, then the watchdog will terminate. + */ +export const watchdog = (child) => { + let dogExited = false; + const dog = spawn(process.execPath, ['-e', watchdogCode, String(child.pid)], { + stdio: 'ignore', + }); + dog.on('exit', () => (dogExited = true)); + child.on('exit', () => { + if (!dogExited) + dog.kill('SIGKILL'); + }); + return dog; +}; +//# sourceMappingURL=watchdog.js.map \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/dist/esm/watchdog.js.map b/tools/ui/node_modules/foreground-child/dist/esm/watchdog.js.map new file mode 100644 index 0000000000000000000000000000000000000000..6f4e39fbd5c61b6b0f3be3f1bfdf901e617df8b4 --- /dev/null +++ b/tools/ui/node_modules/foreground-child/dist/esm/watchdog.js.map @@ -0,0 +1 @@ +{"version":3,"file":"watchdog.js","sourceRoot":"","sources":["../../src/watchdog.ts"],"names":[],"mappings":"AAAA,+DAA+D;AAC/D,gEAAgE;AAChE,uCAAuC;AAEvC,OAAO,EAAgB,KAAK,EAAE,MAAM,eAAe,CAAA;AAEnD,MAAM,YAAY,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;CAqB9B,CAAA;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,KAAmB,EAAE,EAAE;IAC9C,IAAI,SAAS,GAAG,KAAK,CAAA;IACrB,MAAM,GAAG,GAAG,KAAK,CACf,OAAO,CAAC,QAAQ,EAChB,CAAC,IAAI,EAAE,YAAY,EAAE,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EACvC;QACE,KAAK,EAAE,QAAQ;KAChB,CACF,CAAA;IACD,GAAG,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,CAAA;IACxC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,GAAG,EAAE;QACpB,IAAI,CAAC,SAAS;YAAE,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;IACrC,CAAC,CAAC,CAAA;IACF,OAAO,GAAG,CAAA;AACZ,CAAC,CAAA","sourcesContent":["// this spawns a child process that listens for SIGHUP when the\n// parent process exits, and after 200ms, sends a SIGKILL to the\n// child, in case it did not terminate.\n\nimport { ChildProcess, spawn } from 'child_process'\n\nconst watchdogCode = String.raw`\nconst pid = parseInt(process.argv[1], 10)\nprocess.title = 'node (foreground-child watchdog pid=' + pid + ')'\nif (!isNaN(pid)) {\n let barked = false\n // keepalive\n const interval = setInterval(() => {}, 60000)\n const bark = () => {\n clearInterval(interval)\n if (barked) return\n barked = true\n process.removeListener('SIGHUP', bark)\n setTimeout(() => {\n try {\n process.kill(pid, 'SIGKILL')\n setTimeout(() => process.exit(), 200)\n } catch (_) {}\n }, 500)\n })\n process.on('SIGHUP', bark)\n}\n`\n\n/**\n * Pass in a ChildProcess, and this will spawn a watchdog process that\n * will make sure it exits if the parent does, thus preventing any\n * dangling detached zombie processes.\n *\n * If the child ends before the parent, then the watchdog will terminate.\n */\nexport const watchdog = (child: ChildProcess) => {\n let dogExited = false\n const dog = spawn(\n process.execPath,\n ['-e', watchdogCode, String(child.pid)],\n {\n stdio: 'ignore',\n },\n )\n dog.on('exit', () => (dogExited = true))\n child.on('exit', () => {\n if (!dogExited) dog.kill('SIGKILL')\n })\n return dog\n}\n"]} \ No newline at end of file diff --git a/tools/ui/node_modules/foreground-child/package.json b/tools/ui/node_modules/foreground-child/package.json new file mode 100644 index 0000000000000000000000000000000000000000..75f5b9969b282b0a269b976afd251ded58be17ed --- /dev/null +++ b/tools/ui/node_modules/foreground-child/package.json @@ -0,0 +1,106 @@ +{ + "name": "foreground-child", + "version": "3.3.1", + "description": "Run a child as if it's the foreground process. Give it stdio. Exit when it exits.", + "main": "./dist/commonjs/index.js", + "types": "./dist/commonjs/index.d.ts", + "exports": { + "./watchdog": { + "import": { + "types": "./dist/esm/watchdog.d.ts", + "default": "./dist/esm/watchdog.js" + }, + "require": { + "types": "./dist/commonjs/watchdog.d.ts", + "default": "./dist/commonjs/watchdog.js" + } + }, + "./proxy-signals": { + "import": { + "types": "./dist/esm/proxy-signals.d.ts", + "default": "./dist/esm/proxy-signals.js" + }, + "require": { + "types": "./dist/commonjs/proxy-signals.d.ts", + "default": "./dist/commonjs/proxy-signals.js" + } + }, + "./package.json": "./package.json", + ".": { + "import": { + "types": "./dist/esm/index.d.ts", + "default": "./dist/esm/index.js" + }, + "require": { + "types": "./dist/commonjs/index.d.ts", + "default": "./dist/commonjs/index.js" + } + } + }, + "files": [ + "dist" + ], + "engines": { + "node": ">=14" + }, + "dependencies": { + "cross-spawn": "^7.0.6", + "signal-exit": "^4.0.1" + }, + "scripts": { + "preversion": "npm test", + "postversion": "npm publish", + "prepublishOnly": "git push origin --follow-tags", + "prepare": "tshy", + "pretest": "npm run prepare", + "presnap": "npm run prepare", + "test": "tap", + "snap": "tap", + "format": "prettier --write . --log-level warn", + "typedoc": "typedoc --tsconfig .tshy/esm.json ./src/*.ts" + }, + "prettier": { + "experimentalTernaries": true, + "semi": false, + "printWidth": 75, + "tabWidth": 2, + "useTabs": false, + "singleQuote": true, + "jsxSingleQuote": false, + "bracketSameLine": true, + "arrowParens": "avoid", + "endOfLine": "lf" + }, + "tap": { + "typecheck": true + }, + "repository": { + "type": "git", + "url": "git+https://github.com/tapjs/foreground-child.git" + }, + "author": "Isaac Z. Schlueter (http://blog.izs.me/)", + "license": "ISC", + "devDependencies": { + "@types/cross-spawn": "^6.0.2", + "@types/node": "^18.15.11", + "@types/tap": "^15.0.8", + "prettier": "^3.3.2", + "tap": "^21.1.0", + "tshy": "^3.0.2", + "typedoc": "^0.24.2", + "typescript": "^5.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + }, + "tshy": { + "exports": { + "./watchdog": "./src/watchdog.ts", + "./proxy-signals": "./src/proxy-signals.ts", + "./package.json": "./package.json", + ".": "./src/index.ts" + } + }, + "type": "module", + "module": "./dist/esm/index.js" +} diff --git a/tools/ui/node_modules/forwarded/HISTORY.md b/tools/ui/node_modules/forwarded/HISTORY.md new file mode 100644 index 0000000000000000000000000000000000000000..381e6aad4619cbed1e74bf64a0dc3fe216dc0abe --- /dev/null +++ b/tools/ui/node_modules/forwarded/HISTORY.md @@ -0,0 +1,21 @@ +0.2.0 / 2021-05-31 +================== + + * Use `req.socket` over deprecated `req.connection` + +0.1.2 / 2017-09-14 +================== + + * perf: improve header parsing + * perf: reduce overhead when no `X-Forwarded-For` header + +0.1.1 / 2017-09-10 +================== + + * Fix trimming leading / trailing OWS + * perf: hoist regular expression + +0.1.0 / 2014-09-21 +================== + + * Initial release diff --git a/tools/ui/node_modules/forwarded/LICENSE b/tools/ui/node_modules/forwarded/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..84441fbb5709262c2bfc9b5ff0166ad4f024a1b8 --- /dev/null +++ b/tools/ui/node_modules/forwarded/LICENSE @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2014-2017 Douglas Christopher Wilson + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/forwarded/README.md b/tools/ui/node_modules/forwarded/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fdd220bcaab88b00b844736404c326fa6bdfbc0e --- /dev/null +++ b/tools/ui/node_modules/forwarded/README.md @@ -0,0 +1,57 @@ +# forwarded + +[![NPM Version][npm-image]][npm-url] +[![NPM Downloads][downloads-image]][downloads-url] +[![Node.js Version][node-version-image]][node-version-url] +[![Build Status][ci-image]][ci-url] +[![Test Coverage][coveralls-image]][coveralls-url] + +Parse HTTP X-Forwarded-For header + +## Installation + +This is a [Node.js](https://nodejs.org/en/) module available through the +[npm registry](https://www.npmjs.com/). Installation is done using the +[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally): + +```sh +$ npm install forwarded +``` + +## API + +```js +var forwarded = require('forwarded') +``` + +### forwarded(req) + +```js +var addresses = forwarded(req) +``` + +Parse the `X-Forwarded-For` header from the request. Returns an array +of the addresses, including the socket address for the `req`, in reverse +order (i.e. index `0` is the socket address and the last index is the +furthest address, typically the end-user). + +## Testing + +```sh +$ npm test +``` + +## License + +[MIT](LICENSE) + +[ci-image]: https://badgen.net/github/checks/jshttp/forwarded/master?label=ci +[ci-url]: https://github.com/jshttp/forwarded/actions?query=workflow%3Aci +[npm-image]: https://img.shields.io/npm/v/forwarded.svg +[npm-url]: https://npmjs.org/package/forwarded +[node-version-image]: https://img.shields.io/node/v/forwarded.svg +[node-version-url]: https://nodejs.org/en/download/ +[coveralls-image]: https://img.shields.io/coveralls/jshttp/forwarded/master.svg +[coveralls-url]: https://coveralls.io/r/jshttp/forwarded?branch=master +[downloads-image]: https://img.shields.io/npm/dm/forwarded.svg +[downloads-url]: https://npmjs.org/package/forwarded diff --git a/tools/ui/node_modules/forwarded/index.js b/tools/ui/node_modules/forwarded/index.js new file mode 100644 index 0000000000000000000000000000000000000000..b2b6bdd3c98349ba48b5dc150e66746dab1beec1 --- /dev/null +++ b/tools/ui/node_modules/forwarded/index.js @@ -0,0 +1,90 @@ +/*! + * forwarded + * Copyright(c) 2014-2017 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * Module exports. + * @public + */ + +module.exports = forwarded + +/** + * Get all addresses in the request, using the `X-Forwarded-For` header. + * + * @param {object} req + * @return {array} + * @public + */ + +function forwarded (req) { + if (!req) { + throw new TypeError('argument req is required') + } + + // simple header parsing + var proxyAddrs = parse(req.headers['x-forwarded-for'] || '') + var socketAddr = getSocketAddr(req) + var addrs = [socketAddr].concat(proxyAddrs) + + // return all addresses + return addrs +} + +/** + * Get the socket address for a request. + * + * @param {object} req + * @return {string} + * @private + */ + +function getSocketAddr (req) { + return req.socket + ? req.socket.remoteAddress + : req.connection.remoteAddress +} + +/** + * Parse the X-Forwarded-For header. + * + * @param {string} header + * @private + */ + +function parse (header) { + var end = header.length + var list = [] + var start = header.length + + // gather addresses, backwards + for (var i = header.length - 1; i >= 0; i--) { + switch (header.charCodeAt(i)) { + case 0x20: /* */ + if (start === end) { + start = end = i + } + break + case 0x2c: /* , */ + if (start !== end) { + list.push(header.substring(start, end)) + } + start = end = i + break + default: + start = i + break + } + } + + // final address + if (start !== end) { + list.push(header.substring(start, end)) + } + + return list +} diff --git a/tools/ui/node_modules/forwarded/package.json b/tools/ui/node_modules/forwarded/package.json new file mode 100644 index 0000000000000000000000000000000000000000..bf9c7d6550b4efceee2f6f55350860097b218a0a --- /dev/null +++ b/tools/ui/node_modules/forwarded/package.json @@ -0,0 +1,45 @@ +{ + "name": "forwarded", + "description": "Parse HTTP X-Forwarded-For header", + "version": "0.2.0", + "contributors": [ + "Douglas Christopher Wilson " + ], + "license": "MIT", + "keywords": [ + "x-forwarded-for", + "http", + "req" + ], + "repository": "jshttp/forwarded", + "devDependencies": { + "beautify-benchmark": "0.2.4", + "benchmark": "2.1.4", + "deep-equal": "1.0.1", + "eslint": "7.27.0", + "eslint-config-standard": "14.1.1", + "eslint-plugin-import": "2.23.4", + "eslint-plugin-node": "11.1.0", + "eslint-plugin-promise": "4.3.1", + "eslint-plugin-standard": "4.1.0", + "mocha": "8.4.0", + "nyc": "15.1.0" + }, + "files": [ + "LICENSE", + "HISTORY.md", + "README.md", + "index.js" + ], + "engines": { + "node": ">= 0.6" + }, + "scripts": { + "bench": "node benchmark/index.js", + "lint": "eslint .", + "test": "mocha --reporter spec --bail --check-leaks test/", + "test-ci": "nyc --reporter=lcov --reporter=text npm test", + "test-cov": "nyc --reporter=html --reporter=text npm test", + "version": "node scripts/version-history.js && git add HISTORY.md" + } +} diff --git a/tools/ui/node_modules/fresh/HISTORY.md b/tools/ui/node_modules/fresh/HISTORY.md new file mode 100644 index 0000000000000000000000000000000000000000..fd3888acb4dd7a0cdb0dae0761c593c95802d6be --- /dev/null +++ b/tools/ui/node_modules/fresh/HISTORY.md @@ -0,0 +1,80 @@ +2.0.0 - 2024-09-04 +========== + * Drop support for Node.js <18 + +1.0.0 - 2024-09-04 +========== + + * Drop support for Node.js below 0.8 + * Fix: Ignore `If-Modified-Since` in the presence of `If-None-Match`, according to [spec](https://www.rfc-editor.org/rfc/rfc9110.html#section-13.1.3-5). Fixes [#35](https://github.com/jshttp/fresh/issues/35) + +0.5.2 / 2017-09-13 +================== + + * Fix regression matching multiple ETags in `If-None-Match` + * perf: improve `If-None-Match` token parsing + +0.5.1 / 2017-09-11 +================== + + * Fix handling of modified headers with invalid dates + * perf: improve ETag match loop + +0.5.0 / 2017-02-21 +================== + + * Fix incorrect result when `If-None-Match` has both `*` and ETags + * Fix weak `ETag` matching to match spec + * perf: delay reading header values until needed + * perf: skip checking modified time if ETag check failed + * perf: skip parsing `If-None-Match` when no `ETag` header + * perf: use `Date.parse` instead of `new Date` + +0.4.0 / 2017-02-05 +================== + + * Fix false detection of `no-cache` request directive + * perf: enable strict mode + * perf: hoist regular expressions + * perf: remove duplicate conditional + * perf: remove unnecessary boolean coercions + +0.3.0 / 2015-05-12 +================== + + * Add weak `ETag` matching support + +0.2.4 / 2014-09-07 +================== + + * Support Node.js 0.6 + +0.2.3 / 2014-09-07 +================== + + * Move repository to jshttp + +0.2.2 / 2014-02-19 +================== + + * Revert "Fix for blank page on Safari reload" + +0.2.1 / 2014-01-29 +================== + + * Fix for blank page on Safari reload + +0.2.0 / 2013-08-11 +================== + + * Return stale for `Cache-Control: no-cache` + +0.1.0 / 2012-06-15 +================== + + * Add `If-None-Match: *` support + +0.0.1 / 2012-06-10 +================== + + * Initial release diff --git a/tools/ui/node_modules/fresh/LICENSE b/tools/ui/node_modules/fresh/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1434ade75d1fc4faf25a6ac5daed813e12eaed28 --- /dev/null +++ b/tools/ui/node_modules/fresh/LICENSE @@ -0,0 +1,23 @@ +(The MIT License) + +Copyright (c) 2012 TJ Holowaychuk +Copyright (c) 2016-2017 Douglas Christopher Wilson + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/fresh/README.md b/tools/ui/node_modules/fresh/README.md new file mode 100644 index 0000000000000000000000000000000000000000..fd79c5b525a9d373331b39a48eaced9003877f1a --- /dev/null +++ b/tools/ui/node_modules/fresh/README.md @@ -0,0 +1,117 @@ +# fresh + +[![NPM Version][npm-image]][npm-url] +[![NPM Downloads][downloads-image]][downloads-url] +[![Node.js Version][node-version-image]][node-version-url] +[![Build Status][ci-image]][ci-url] +[![Test Coverage][coveralls-image]][coveralls-url] + +HTTP response freshness testing + +## Installation + +This is a [Node.js](https://nodejs.org/en/) module available through the +[npm registry](https://www.npmjs.com/). Installation is done using the +[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally): + +``` +$ npm install fresh +``` + +## API + +```js +var fresh = require('fresh') +``` + +### fresh(reqHeaders, resHeaders) + +Check freshness of the response using request and response headers. + +When the response is still "fresh" in the client's cache `true` is +returned, otherwise `false` is returned to indicate that the client +cache is now stale and the full response should be sent. + +When a client sends the `Cache-Control: no-cache` request header to +indicate an end-to-end reload request, this module will return `false` +to make handling these requests transparent. + +## Known Issues + +This module is designed to only follow the HTTP specifications, not +to work-around all kinda of client bugs (especially since this module +typically does not receive enough information to understand what the +client actually is). + +There is a known issue that in certain versions of Safari, Safari +will incorrectly make a request that allows this module to validate +freshness of the resource even when Safari does not have a +representation of the resource in the cache. The module +[jumanji](https://www.npmjs.com/package/jumanji) can be used in +an Express application to work-around this issue and also provides +links to further reading on this Safari bug. + +## Example + +### API usage + + + +```js +var reqHeaders = { 'if-none-match': '"foo"' } +var resHeaders = { etag: '"bar"' } +fresh(reqHeaders, resHeaders) +// => false + +var reqHeaders = { 'if-none-match': '"foo"' } +var resHeaders = { etag: '"foo"' } +fresh(reqHeaders, resHeaders) +// => true +``` + +### Using with Node.js http server + +```js +var fresh = require('fresh') +var http = require('http') + +var server = http.createServer(function (req, res) { + // perform server logic + // ... including adding ETag / Last-Modified response headers + + if (isFresh(req, res)) { + // client has a fresh copy of resource + res.statusCode = 304 + res.end() + return + } + + // send the resource + res.statusCode = 200 + res.end('hello, world!') +}) + +function isFresh (req, res) { + return fresh(req.headers, { + etag: res.getHeader('ETag'), + 'last-modified': res.getHeader('Last-Modified') + }) +} + +server.listen(3000) +``` + +## License + +[MIT](LICENSE) + +[ci-image]: https://img.shields.io/github/workflow/status/jshttp/fresh/ci/master?label=ci +[ci-url]: https://github.com/jshttp/fresh/actions/workflows/ci.yml +[npm-image]: https://img.shields.io/npm/v/fresh.svg +[npm-url]: https://npmjs.org/package/fresh +[node-version-image]: https://img.shields.io/node/v/fresh.svg +[node-version-url]: https://nodejs.org/en/ +[coveralls-image]: https://img.shields.io/coveralls/jshttp/fresh/master.svg +[coveralls-url]: https://coveralls.io/r/jshttp/fresh?branch=master +[downloads-image]: https://img.shields.io/npm/dm/fresh.svg +[downloads-url]: https://npmjs.org/package/fresh diff --git a/tools/ui/node_modules/fresh/index.js b/tools/ui/node_modules/fresh/index.js new file mode 100644 index 0000000000000000000000000000000000000000..fc3dea7b4ae085168714ffb7b7fbe01646e858a5 --- /dev/null +++ b/tools/ui/node_modules/fresh/index.js @@ -0,0 +1,136 @@ +/*! + * fresh + * Copyright(c) 2012 TJ Holowaychuk + * Copyright(c) 2016-2017 Douglas Christopher Wilson + * MIT Licensed + */ + +'use strict' + +/** + * RegExp to check for no-cache token in Cache-Control. + * @private + */ + +var CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/ + +/** + * Module exports. + * @public + */ + +module.exports = fresh + +/** + * Check freshness of the response using request and response headers. + * + * @param {Object} reqHeaders + * @param {Object} resHeaders + * @return {Boolean} + * @public + */ + +function fresh (reqHeaders, resHeaders) { + // fields + var modifiedSince = reqHeaders['if-modified-since'] + var noneMatch = reqHeaders['if-none-match'] + + // unconditional request + if (!modifiedSince && !noneMatch) { + return false + } + + // Always return stale when Cache-Control: no-cache + // to support end-to-end reload requests + // https://tools.ietf.org/html/rfc2616#section-14.9.4 + var cacheControl = reqHeaders['cache-control'] + if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl)) { + return false + } + + // if-none-match takes precedent over if-modified-since + if (noneMatch) { + if (noneMatch === '*') { + return true + } + var etag = resHeaders.etag + + if (!etag) { + return false + } + + var matches = parseTokenList(noneMatch) + for (var i = 0; i < matches.length; i++) { + var match = matches[i] + if (match === etag || match === 'W/' + etag || 'W/' + match === etag) { + return true + } + } + + return false + } + + // if-modified-since + if (modifiedSince) { + var lastModified = resHeaders['last-modified'] + var modifiedStale = !lastModified || !(parseHttpDate(lastModified) <= parseHttpDate(modifiedSince)) + + if (modifiedStale) { + return false + } + } + + return true +} + +/** + * Parse an HTTP Date into a number. + * + * @param {string} date + * @private + */ + +function parseHttpDate (date) { + var timestamp = date && Date.parse(date) + + // istanbul ignore next: guard against date.js Date.parse patching + return typeof timestamp === 'number' + ? timestamp + : NaN +} + +/** + * Parse a HTTP token list. + * + * @param {string} str + * @private + */ + +function parseTokenList (str) { + var end = 0 + var list = [] + var start = 0 + + // gather tokens + for (var i = 0, len = str.length; i < len; i++) { + switch (str.charCodeAt(i)) { + case 0x20: /* */ + if (start === end) { + start = end = i + 1 + } + break + case 0x2c: /* , */ + list.push(str.substring(start, end)) + start = end = i + 1 + break + default: + end = i + 1 + break + } + } + + // final token + list.push(str.substring(start, end)) + + return list +} diff --git a/tools/ui/node_modules/fresh/package.json b/tools/ui/node_modules/fresh/package.json new file mode 100644 index 0000000000000000000000000000000000000000..5d7e2157f31d97514c00437582b77d3686b12ebd --- /dev/null +++ b/tools/ui/node_modules/fresh/package.json @@ -0,0 +1,46 @@ +{ + "name": "fresh", + "description": "HTTP response freshness testing", + "version": "2.0.0", + "author": "TJ Holowaychuk (http://tjholowaychuk.com)", + "contributors": [ + "Douglas Christopher Wilson ", + "Jonathan Ong (http://jongleberry.com)" + ], + "license": "MIT", + "keywords": [ + "fresh", + "http", + "conditional", + "cache" + ], + "repository": "jshttp/fresh", + "devDependencies": { + "beautify-benchmark": "0.2.4", + "benchmark": "2.1.4", + "eslint": "8.12.0", + "eslint-config-standard": "14.1.1", + "eslint-plugin-import": "2.25.4", + "eslint-plugin-markdown": "2.2.1", + "eslint-plugin-node": "11.1.0", + "eslint-plugin-promise": "6.0.0", + "eslint-plugin-standard": "4.1.0", + "mocha": "9.2.0", + "nyc": "15.1.0" + }, + "files": [ + "HISTORY.md", + "LICENSE", + "index.js" + ], + "engines": { + "node": ">= 0.8" + }, + "scripts": { + "bench": "node benchmark/index.js", + "lint": "eslint .", + "test": "mocha --reporter spec --check-leaks --bail test/", + "test-ci": "nyc --reporter=lcov --reporter=text npm test", + "test-cov": "nyc --reporter=html --reporter=text npm test" + } +} diff --git a/tools/ui/node_modules/fs-extra/CHANGELOG.md b/tools/ui/node_modules/fs-extra/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..225fdcaab5eb501d97387962ab8943c57d5d9a2b --- /dev/null +++ b/tools/ui/node_modules/fs-extra/CHANGELOG.md @@ -0,0 +1,902 @@ +9.1.0 / 2021-01-19 +------------------ + +- Add promise support for `fs.rm()` ([#841](https://github.com/jprichardson/node-fs-extra/issues/841), [#860](https://github.com/jprichardson/node-fs-extra/pull/860)) +- Upgrade universalify for performance improvments ([#825](https://github.com/jprichardson/node-fs-extra/pull/825)) + +9.0.1 / 2020-06-03 +------------------ + +- Fix issue with `ensureFile()` when used with Jest on Windows ([#804](https://github.com/jprichardson/node-fs-extra/issues/804), [#805](https://github.com/jprichardson/node-fs-extra/pull/805)) +- Remove unneeded `process.umask()` call ([#791](https://github.com/jprichardson/node-fs-extra/pull/791)) +- Docs improvements ([#753](https://github.com/jprichardson/node-fs-extra/pull/753), [#795](https://github.com/jprichardson/node-fs-extra/pull/795), [#797](https://github.com/jprichardson/node-fs-extra/pull/797)) + +9.0.0 / 2020-03-19 +------------------ + +### Breaking changes + +- Requires Node.js version 10 or greater ([#725](https://github.com/jprichardson/node-fs-extra/issues/725), [#751](https://github.com/jprichardson/node-fs-extra/pull/751)) +- Switched `ensureDir*` to use a fork of https://github.com/sindresorhus/make-dir to make use of native recursive `fs.mkdir` where possible ([#619](https://github.com/jprichardson/node-fs-extra/issues/619), [#756](https://github.com/jprichardson/node-fs-extra/pull/756)) +- Properly preserve `atime` for `copy*` with `preserveTimestamps` option ([#633](https://github.com/jprichardson/node-fs-extra/pull/633)) + +**The following changes, allthough technically breaking, will not affect the vast majority of users:** + +- `outputJson` now outputs objects as they were when the function was called, even if they are mutated later ([#702](https://github.com/jprichardson/node-fs-extra/issues/702), [#768](https://github.com/jprichardson/node-fs-extra/pull/768)) +- Cannot pass `null` as an options parameter to `*Json*` methods ([#745](https://github.com/jprichardson/node-fs-extra/issues/745), [#768](https://github.com/jprichardson/node-fs-extra/pull/768)) + +### Improvements + +- Add promise shims for `fs.writev` & `fs.opendir` ([#747](https://github.com/jprichardson/node-fs-extra/pull/747)) +- Better errors for `ensureFile` ([#696](https://github.com/jprichardson/node-fs-extra/issues/696), [#744](https://github.com/jprichardson/node-fs-extra/pull/744)) +- Better file comparison for older Node versions ([#694](https://github.com/jprichardson/node-fs-extra/pull/694)) + +### Miscellaneous changes +- Peformance optimizations ([#762](https://github.com/jprichardson/node-fs-extra/issues/762), [#764](https://github.com/jprichardson/node-fs-extra/pull/764)) +- Add missing documentation for aliases ([#758](https://github.com/jprichardson/node-fs-extra/issues/758), [#766](https://github.com/jprichardson/node-fs-extra/pull/766)) +- Update `universalify` dependency ([#767](https://github.com/jprichardson/node-fs-extra/pull/767)) + +8.1.0 / 2019-06-28 +------------------ + +- Add support for promisified `fs.realpath.native` in Node v9.2+ ([#650](https://github.com/jprichardson/node-fs-extra/issues/650), [#682](https://github.com/jprichardson/node-fs-extra/pull/682)) +- Update `graceful-fs` dependency ([#700](https://github.com/jprichardson/node-fs-extra/pull/700)) +- Use `graceful-fs` everywhere ([#700](https://github.com/jprichardson/node-fs-extra/pull/700)) + +8.0.1 / 2019-05-13 +------------------ + +- Fix bug `Maximum call stack size exceeded` error in `util/stat` ([#679](https://github.com/jprichardson/node-fs-extra/pull/679)) + +8.0.0 / 2019-05-11 +------------------ + +**NOTE:** Node.js v6 support is deprecated, and will be dropped in the next major release. + +- Use `renameSync()` under the hood in `moveSync()` +- Fix bug with bind-mounted directories in `copy*()` ([#613](https://github.com/jprichardson/node-fs-extra/issues/613), [#618](https://github.com/jprichardson/node-fs-extra/pull/618)) +- Fix bug in `move()` with case-insensitive file systems +- Use `fs.stat()`'s `bigint` option in `copy*()` & `move*()` where possible ([#657](https://github.com/jprichardson/node-fs-extra/issues/657)) + +7.0.1 / 2018-11-07 +------------------ + +- Fix `removeSync()` on Windows, in some cases, it would error out with `ENOTEMPTY` ([#646](https://github.com/jprichardson/node-fs-extra/pull/646)) +- Document `mode` option for `ensureDir*()` ([#587](https://github.com/jprichardson/node-fs-extra/pull/587)) +- Don't include documentation files in npm package tarball ([#642](https://github.com/jprichardson/node-fs-extra/issues/642), [#643](https://github.com/jprichardson/node-fs-extra/pull/643)) + +7.0.0 / 2018-07-16 +------------------ + +- **BREAKING:** Refine `copy*()` handling of symlinks to properly detect symlinks that point to the same file. ([#582](https://github.com/jprichardson/node-fs-extra/pull/582)) +- Fix bug with copying write-protected directories ([#600](https://github.com/jprichardson/node-fs-extra/pull/600)) +- Universalify `fs.lchmod()` ([#596](https://github.com/jprichardson/node-fs-extra/pull/596)) +- Add `engines` field to `package.json` ([#580](https://github.com/jprichardson/node-fs-extra/pull/580)) + +6.0.1 / 2018-05-09 +------------------ + +- Fix `fs.promises` `ExperimentalWarning` on Node v10.1.0 ([#578](https://github.com/jprichardson/node-fs-extra/pull/578)) + +6.0.0 / 2018-05-01 +------------------ + +- Drop support for Node.js versions 4, 5, & 7 ([#564](https://github.com/jprichardson/node-fs-extra/pull/564)) +- Rewrite `move` to use `fs.rename` where possible ([#549](https://github.com/jprichardson/node-fs-extra/pull/549)) +- Don't convert relative paths to absolute paths for `filter` ([#554](https://github.com/jprichardson/node-fs-extra/pull/554)) +- `copy*`'s behavior when `preserveTimestamps` is `false` has been OS-dependent since 5.0.0, but that's now explicitly noted in the docs ([#563](https://github.com/jprichardson/node-fs-extra/pull/563)) +- Fix subdirectory detection for `copy*` & `move*` ([#541](https://github.com/jprichardson/node-fs-extra/pull/541)) +- Handle case-insensitive paths correctly in `copy*` ([#568](https://github.com/jprichardson/node-fs-extra/pull/568)) + +5.0.0 / 2017-12-11 +------------------ + +Significant refactor of `copy()` & `copySync()`, including breaking changes. No changes to other functions in this release. + +Huge thanks to **[@manidlou](https://github.com/manidlou)** for doing most of the work on this release. + +- The `filter` option can no longer be a RegExp (must be a function). This was deprecated since fs-extra v1.0.0. [#512](https://github.com/jprichardson/node-fs-extra/pull/512) +- `copy()`'s `filter` option can now be a function that returns a Promise. [#518](https://github.com/jprichardson/node-fs-extra/pull/518) +- `copy()` & `copySync()` now use `fs.copyFile()`/`fs.copyFileSync()` in environments that support it (currently Node 8.5.0+). Older Node versions still get the old implementation. [#505](https://github.com/jprichardson/node-fs-extra/pull/505) +- Don't allow copying a directory into itself. [#83](https://github.com/jprichardson/node-fs-extra/issues/83) +- Handle copying between identical files. [#198](https://github.com/jprichardson/node-fs-extra/issues/198) +- Error out when copying an empty folder to a path that already exists. [#464](https://github.com/jprichardson/node-fs-extra/issues/464) +- Don't create `dest`'s parent if the `filter` function aborts the `copy()` operation. [#517](https://github.com/jprichardson/node-fs-extra/pull/517) +- Fix `writeStream` not being closed if there was an error in `copy()`. [#516](https://github.com/jprichardson/node-fs-extra/pull/516) + +4.0.3 / 2017-12-05 +------------------ + +- Fix wrong `chmod` values in `fs.remove()` [#501](https://github.com/jprichardson/node-fs-extra/pull/501) +- Fix `TypeError` on systems that don't have some `fs` operations like `lchown` [#520](https://github.com/jprichardson/node-fs-extra/pull/520) + +4.0.2 / 2017-09-12 +------------------ + +- Added `EOL` option to `writeJson*` & `outputJson*` (via upgrade to jsonfile v4) +- Added promise support to [`fs.copyFile()`](https://nodejs.org/api/fs.html#fs_fs_copyfile_src_dest_flags_callback) in Node 8.5+ +- Added `.js` extension to `main` field in `package.json` for better tooling compatibility. [#485](https://github.com/jprichardson/node-fs-extra/pull/485) + +4.0.1 / 2017-07-31 +------------------ + +### Fixed + +- Previously, `ensureFile()` & `ensureFileSync()` would do nothing if the path was a directory. Now, they error out for consistency with `ensureDir()`. [#465](https://github.com/jprichardson/node-fs-extra/issues/465), [#466](https://github.com/jprichardson/node-fs-extra/pull/466), [#470](https://github.com/jprichardson/node-fs-extra/issues/470) + +4.0.0 / 2017-07-14 +------------------ + +### Changed + +- **BREAKING:** The promisified versions of `fs.read()` & `fs.write()` now return objects. See [the docs](docs/fs-read-write.md) for details. [#436](https://github.com/jprichardson/node-fs-extra/issues/436), [#449](https://github.com/jprichardson/node-fs-extra/pull/449) +- `fs.move()` now errors out when destination is a subdirectory of source. [#458](https://github.com/jprichardson/node-fs-extra/pull/458) +- Applied upstream fixes from `rimraf` to `fs.remove()` & `fs.removeSync()`. [#459](https://github.com/jprichardson/node-fs-extra/pull/459) + +### Fixed + +- Got `fs.outputJSONSync()` working again; it was broken due to refactoring. [#428](https://github.com/jprichardson/node-fs-extra/pull/428) + +Also clarified the docs in a few places. + +3.0.1 / 2017-05-04 +------------------ + +- Fix bug in `move()` & `moveSync()` when source and destination are the same, and source does not exist. [#415](https://github.com/jprichardson/node-fs-extra/pull/415) + +3.0.0 / 2017-04-27 +------------------ + +### Added + +- **BREAKING:** Added Promise support. All asynchronous native fs methods and fs-extra methods now return a promise if the callback is not passed. [#403](https://github.com/jprichardson/node-fs-extra/pull/403) +- `pathExists()`, a replacement for the deprecated `fs.exists`. `pathExists` has a normal error-first callback signature. Also added `pathExistsSync`, an alias to `fs.existsSync`, for completeness. [#406](https://github.com/jprichardson/node-fs-extra/pull/406) + +### Removed + +- **BREAKING:** Removed support for setting the default spaces for `writeJson()`, `writeJsonSync()`, `outputJson()`, & `outputJsonSync()`. This was undocumented. [#402](https://github.com/jprichardson/node-fs-extra/pull/402) + +### Changed + +- Upgraded jsonfile dependency to v3.0.0: + - **BREAKING:** Changed behavior of `throws` option for `readJsonSync()`; now does not throw filesystem errors when `throws` is `false`. +- **BREAKING:** `writeJson()`, `writeJsonSync()`, `outputJson()`, & `outputJsonSync()` now output minified JSON by default for consistency with `JSON.stringify()`; set the `spaces` option to `2` to override this new behavior. [#402](https://github.com/jprichardson/node-fs-extra/pull/402) +- Use `Buffer.allocUnsafe()` instead of `new Buffer()` in environments that support it. [#394](https://github.com/jprichardson/node-fs-extra/pull/394) + +### Fixed + +- `removeSync()` silently failed on Windows in some cases. Now throws an `EBUSY` error. [#408](https://github.com/jprichardson/node-fs-extra/pull/408) + +2.1.2 / 2017-03-16 +------------------ + +### Fixed + +- Weird windows bug that resulted in `ensureDir()`'s callback being called twice in some cases. This bug may have also affected `remove()`. See [#392](https://github.com/jprichardson/node-fs-extra/issues/392), [#393](https://github.com/jprichardson/node-fs-extra/pull/393) + +2.1.1 / 2017-03-15 +------------------ + +### Fixed + +- Reverted [`5597bd`](https://github.com/jprichardson/node-fs-extra/commit/5597bd5b67f7d060f5f5bf26e9635be48330f5d7), this broke compatibility with Node.js versions v4+ but less than `v4.5.0`. +- Remove `Buffer.alloc()` usage in `moveSync()`. + +2.1.0 / 2017-03-15 +------------------ + +Thanks to [Mani Maghsoudlou (@manidlou)](https://github.com/manidlou) & [Jan Peer Stöcklmair (@JPeer264)](https://github.com/JPeer264) for their extraordinary help with this release! + +### Added +- `moveSync()` See [#309], [#381](https://github.com/jprichardson/node-fs-extra/pull/381). ([@manidlou](https://github.com/manidlou)) +- `copy()` and `copySync()`'s `filter` option now gets the destination path passed as the second parameter. [#366](https://github.com/jprichardson/node-fs-extra/pull/366) ([@manidlou](https://github.com/manidlou)) + +### Changed +- Use `Buffer.alloc()` instead of deprecated `new Buffer()` in `copySync()`. [#380](https://github.com/jprichardson/node-fs-extra/pull/380) ([@manidlou](https://github.com/manidlou)) +- Refactored entire codebase to use ES6 features supported by Node.js v4+ [#355](https://github.com/jprichardson/node-fs-extra/issues/355). [(@JPeer264)](https://github.com/JPeer264) +- Refactored docs. ([@manidlou](https://github.com/manidlou)) + +### Fixed + +- `move()` shouldn't error out when source and dest are the same. [#377](https://github.com/jprichardson/node-fs-extra/issues/377), [#378](https://github.com/jprichardson/node-fs-extra/pull/378) ([@jdalton](https://github.com/jdalton)) + +2.0.0 / 2017-01-16 +------------------ + +### Removed +- **BREAKING:** Removed support for Node `v0.12`. The Node foundation stopped officially supporting it +on Jan 1st, 2017. +- **BREAKING:** Remove `walk()` and `walkSync()`. `walkSync()` was only part of `fs-extra` for a little +over two months. Use [klaw](https://github.com/jprichardson/node-klaw) instead of `walk()`, in fact, `walk()` was just +an alias to klaw. For `walkSync()` use [klaw-sync](https://github.com/mawni/node-klaw-sync). See: [#338], [#339] + +### Changed +- **BREAKING:** Renamed `clobber` to `overwrite`. This affects `copy()`, `copySync()`, and `move()`. [#330], [#333] +- Moved docs, to `docs/`. [#340] + +### Fixed +- Apply filters to directories in `copySync()` like in `copy()`. [#324] +- A specific condition when disk is under heavy use, `copy()` can fail. [#326] + + +1.0.0 / 2016-11-01 +------------------ + +After five years of development, we finally have reach the 1.0.0 milestone! Big thanks goes +to [Ryan Zim](https://github.com/RyanZim) for leading the charge on this release! + +### Added +- `walkSync()` + +### Changed +- **BREAKING**: dropped Node v0.10 support. +- disabled `rimaf` globbing, wasn't used. [#280] +- deprecate `copy()/copySync()` option `filter` if it's a `RegExp`. `filter` should now be a function. +- inline `rimraf`. This is temporary and was done because `rimraf` depended upon the beefy `glob` which `fs-extra` does not use. [#300] + +### Fixed +- bug fix proper closing of file handle on `utimesMillis()` [#271] +- proper escaping of files with dollar signs [#291] +- `copySync()` failed if user didn't own file. [#199], [#301] + + +0.30.0 / 2016-04-28 +------------------- +- Brought back Node v0.10 support. I didn't realize there was still demand. Official support will end **2016-10-01**. + +0.29.0 / 2016-04-27 +------------------- +- **BREAKING**: removed support for Node v0.10. If you still want to use Node v0.10, everything should work except for `ensureLink()/ensureSymlink()`. Node v0.12 is still supported but will be dropped in the near future as well. + +0.28.0 / 2016-04-17 +------------------- +- **BREAKING**: removed `createOutputStream()`. Use https://www.npmjs.com/package/create-output-stream. See: [#192][#192] +- `mkdirs()/mkdirsSync()` check for invalid win32 path chars. See: [#209][#209], [#237][#237] +- `mkdirs()/mkdirsSync()` if drive not mounted, error. See: [#93][#93] + +0.27.0 / 2016-04-15 +------------------- +- add `dereference` option to `copySync()`. [#235][#235] + +0.26.7 / 2016-03-16 +------------------- +- fixed `copy()` if source and dest are the same. [#230][#230] + +0.26.6 / 2016-03-15 +------------------- +- fixed if `emptyDir()` does not have a callback: [#229][#229] + +0.26.5 / 2016-01-27 +------------------- +- `copy()` with two arguments (w/o callback) was broken. See: [#215][#215] + +0.26.4 / 2016-01-05 +------------------- +- `copySync()` made `preserveTimestamps` default consistent with `copy()` which is `false`. See: [#208][#208] + +0.26.3 / 2015-12-17 +------------------- +- fixed `copy()` hangup in copying blockDevice / characterDevice / `/dev/null`. See: [#193][#193] + +0.26.2 / 2015-11-02 +------------------- +- fixed `outputJson{Sync}()` spacing adherence to `fs.spaces` + +0.26.1 / 2015-11-02 +------------------- +- fixed `copySync()` when `clogger=true` and the destination is read only. See: [#190][#190] + +0.26.0 / 2015-10-25 +------------------- +- extracted the `walk()` function into its own module [`klaw`](https://github.com/jprichardson/node-klaw). + +0.25.0 / 2015-10-24 +------------------- +- now has a file walker `walk()` + +0.24.0 / 2015-08-28 +------------------- +- removed alias `delete()` and `deleteSync()`. See: [#171][#171] + +0.23.1 / 2015-08-07 +------------------- +- Better handling of errors for `move()` when moving across devices. [#170][#170] +- `ensureSymlink()` and `ensureLink()` should not throw errors if link exists. [#169][#169] + +0.23.0 / 2015-08-06 +------------------- +- added `ensureLink{Sync}()` and `ensureSymlink{Sync}()`. See: [#165][#165] + +0.22.1 / 2015-07-09 +------------------- +- Prevent calling `hasMillisResSync()` on module load. See: [#149][#149]. +Fixes regression that was introduced in `0.21.0`. + +0.22.0 / 2015-07-09 +------------------- +- preserve permissions / ownership in `copy()`. See: [#54][#54] + +0.21.0 / 2015-07-04 +------------------- +- add option to preserve timestamps in `copy()` and `copySync()`. See: [#141][#141] +- updated `graceful-fs@3.x` to `4.x`. This brings in features from `amazing-graceful-fs` (much cleaner code / less hacks) + +0.20.1 / 2015-06-23 +------------------- +- fixed regression caused by latest jsonfile update: See: https://github.com/jprichardson/node-jsonfile/issues/26 + +0.20.0 / 2015-06-19 +------------------- +- removed `jsonfile` aliases with `File` in the name, they weren't documented and probably weren't in use e.g. +this package had both `fs.readJsonFile` and `fs.readJson` that were aliases to each other, now use `fs.readJson`. +- preliminary walker created. Intentionally not documented. If you use it, it will almost certainly change and break your code. +- started moving tests inline +- upgraded to `jsonfile@2.1.0`, can now pass JSON revivers/replacers to `readJson()`, `writeJson()`, `outputJson()` + +0.19.0 / 2015-06-08 +------------------- +- `fs.copy()` had support for Node v0.8, dropped support + +0.18.4 / 2015-05-22 +------------------- +- fixed license field according to this: [#136][#136] and https://github.com/npm/npm/releases/tag/v2.10.0 + +0.18.3 / 2015-05-08 +------------------- +- bugfix: handle `EEXIST` when clobbering on some Linux systems. [#134][#134] + +0.18.2 / 2015-04-17 +------------------- +- bugfix: allow `F_OK` ([#120][#120]) + +0.18.1 / 2015-04-15 +------------------- +- improved windows support for `move()` a bit. https://github.com/jprichardson/node-fs-extra/commit/92838980f25dc2ee4ec46b43ee14d3c4a1d30c1b +- fixed a lot of tests for Windows (appveyor) + +0.18.0 / 2015-03-31 +------------------- +- added `emptyDir()` and `emptyDirSync()` + +0.17.0 / 2015-03-28 +------------------- +- `copySync` added `clobber` option (before always would clobber, now if `clobber` is `false` it throws an error if the destination exists). +**Only works with files at the moment.** +- `createOutputStream()` added. See: [#118][#118] + +0.16.5 / 2015-03-08 +------------------- +- fixed `fs.move` when `clobber` is `true` and destination is a directory, it should clobber. [#114][#114] + +0.16.4 / 2015-03-01 +------------------- +- `fs.mkdirs` fix infinite loop on Windows. See: See https://github.com/substack/node-mkdirp/pull/74 and https://github.com/substack/node-mkdirp/issues/66 + +0.16.3 / 2015-01-28 +------------------- +- reverted https://github.com/jprichardson/node-fs-extra/commit/1ee77c8a805eba5b99382a2591ff99667847c9c9 + + +0.16.2 / 2015-01-28 +------------------- +- fixed `fs.copy` for Node v0.8 (support is temporary and will be removed in the near future) + +0.16.1 / 2015-01-28 +------------------- +- if `setImmediate` is not available, fall back to `process.nextTick` + +0.16.0 / 2015-01-28 +------------------- +- bugfix `fs.move()` into itself. Closes [#104] +- bugfix `fs.move()` moving directory across device. Closes [#108] +- added coveralls support +- bugfix: nasty multiple callback `fs.copy()` bug. Closes [#98] +- misc fs.copy code cleanups + +0.15.0 / 2015-01-21 +------------------- +- dropped `ncp`, imported code in +- because of previous, now supports `io.js` +- `graceful-fs` is now a dependency + +0.14.0 / 2015-01-05 +------------------- +- changed `copy`/`copySync` from `fs.copy(src, dest, [filters], callback)` to `fs.copy(src, dest, [options], callback)` [#100][#100] +- removed mockfs tests for mkdirp (this may be temporary, but was getting in the way of other tests) + +0.13.0 / 2014-12-10 +------------------- +- removed `touch` and `touchSync` methods (they didn't handle permissions like UNIX touch) +- updated `"ncp": "^0.6.0"` to `"ncp": "^1.0.1"` +- imported `mkdirp` => `minimist` and `mkdirp` are no longer dependences, should now appease people who wanted `mkdirp` to be `--use_strict` safe. See [#59]([#59][#59]) + +0.12.0 / 2014-09-22 +------------------- +- copy symlinks in `copySync()` [#85][#85] + +0.11.1 / 2014-09-02 +------------------- +- bugfix `copySync()` preserve file permissions [#80][#80] + +0.11.0 / 2014-08-11 +------------------- +- upgraded `"ncp": "^0.5.1"` to `"ncp": "^0.6.0"` +- upgrade `jsonfile": "^1.2.0"` to `jsonfile": "^2.0.0"` => on write, json files now have `\n` at end. Also adds `options.throws` to `readJsonSync()` +see https://github.com/jprichardson/node-jsonfile#readfilesyncfilename-options for more details. + +0.10.0 / 2014-06-29 +------------------ +* bugfix: upgaded `"jsonfile": "~1.1.0"` to `"jsonfile": "^1.2.0"`, bumped minor because of `jsonfile` dep change +from `~` to `^`. [#67] + +0.9.1 / 2014-05-22 +------------------ +* removed Node.js `0.8.x` support, `0.9.0` was published moments ago and should have been done there + +0.9.0 / 2014-05-22 +------------------ +* upgraded `ncp` from `~0.4.2` to `^0.5.1`, [#58] +* upgraded `rimraf` from `~2.2.6` to `^2.2.8` +* upgraded `mkdirp` from `0.3.x` to `^0.5.0` +* added methods `ensureFile()`, `ensureFileSync()` +* added methods `ensureDir()`, `ensureDirSync()` [#31] +* added `move()` method. From: https://github.com/andrewrk/node-mv + + +0.8.1 / 2013-10-24 +------------------ +* copy failed to return an error to the callback if a file doesn't exist (ulikoehler [#38], [#39]) + +0.8.0 / 2013-10-14 +------------------ +* `filter` implemented on `copy()` and `copySync()`. (Srirangan / [#36]) + +0.7.1 / 2013-10-12 +------------------ +* `copySync()` implemented (Srirangan / [#33]) +* updated to the latest `jsonfile` version `1.1.0` which gives `options` params for the JSON methods. Closes [#32] + +0.7.0 / 2013-10-07 +------------------ +* update readme conventions +* `copy()` now works if destination directory does not exist. Closes [#29] + +0.6.4 / 2013-09-05 +------------------ +* changed `homepage` field in package.json to remove NPM warning + +0.6.3 / 2013-06-28 +------------------ +* changed JSON spacing default from `4` to `2` to follow Node conventions +* updated `jsonfile` dep +* updated `rimraf` dep + +0.6.2 / 2013-06-28 +------------------ +* added .npmignore, [#25] + +0.6.1 / 2013-05-14 +------------------ +* modified for `strict` mode, closes [#24] +* added `outputJson()/outputJsonSync()`, closes [#23] + +0.6.0 / 2013-03-18 +------------------ +* removed node 0.6 support +* added node 0.10 support +* upgraded to latest `ncp` and `rimraf`. +* optional `graceful-fs` support. Closes [#17] + + +0.5.0 / 2013-02-03 +------------------ +* Removed `readTextFile`. +* Renamed `readJSONFile` to `readJSON` and `readJson`, same with write. +* Restructured documentation a bit. Added roadmap. + +0.4.0 / 2013-01-28 +------------------ +* Set default spaces in `jsonfile` from 4 to 2. +* Updated `testutil` deps for tests. +* Renamed `touch()` to `createFile()` +* Added `outputFile()` and `outputFileSync()` +* Changed creation of testing diretories so the /tmp dir is not littered. +* Added `readTextFile()` and `readTextFileSync()`. + +0.3.2 / 2012-11-01 +------------------ +* Added `touch()` and `touchSync()` methods. + +0.3.1 / 2012-10-11 +------------------ +* Fixed some stray globals. + +0.3.0 / 2012-10-09 +------------------ +* Removed all CoffeeScript from tests. +* Renamed `mkdir` to `mkdirs`/`mkdirp`. + +0.2.1 / 2012-09-11 +------------------ +* Updated `rimraf` dep. + +0.2.0 / 2012-09-10 +------------------ +* Rewrote module into JavaScript. (Must still rewrite tests into JavaScript) +* Added all methods of [jsonfile](https://github.com/jprichardson/node-jsonfile) +* Added Travis-CI. + +0.1.3 / 2012-08-13 +------------------ +* Added method `readJSONFile`. + +0.1.2 / 2012-06-15 +------------------ +* Bug fix: `deleteSync()` didn't exist. +* Verified Node v0.8 compatibility. + +0.1.1 / 2012-06-15 +------------------ +* Fixed bug in `remove()`/`delete()` that wouldn't execute the function if a callback wasn't passed. + +0.1.0 / 2012-05-31 +------------------ +* Renamed `copyFile()` to `copy()`. `copy()` can now copy directories (recursively) too. +* Renamed `rmrf()` to `remove()`. +* `remove()` aliased with `delete()`. +* Added `mkdirp` capabilities. Named: `mkdir()`. Hides Node.js native `mkdir()`. +* Instead of exporting the native `fs` module with new functions, I now copy over the native methods to a new object and export that instead. + +0.0.4 / 2012-03-14 +------------------ +* Removed CoffeeScript dependency + +0.0.3 / 2012-01-11 +------------------ +* Added methods rmrf and rmrfSync +* Moved tests from Jasmine to Mocha + + +[#344]: https://github.com/jprichardson/node-fs-extra/issues/344 "Licence Year" +[#343]: https://github.com/jprichardson/node-fs-extra/pull/343 "Add klaw-sync link to readme" +[#342]: https://github.com/jprichardson/node-fs-extra/pull/342 "allow preserveTimestamps when use move" +[#341]: https://github.com/jprichardson/node-fs-extra/issues/341 "mkdirp(path.dirname(dest) in move() logic needs cleaning up [question]" +[#340]: https://github.com/jprichardson/node-fs-extra/pull/340 "Move docs to seperate docs folder [documentation]" +[#339]: https://github.com/jprichardson/node-fs-extra/pull/339 "Remove walk() & walkSync() [feature-walk]" +[#338]: https://github.com/jprichardson/node-fs-extra/issues/338 "Remove walk() and walkSync() [feature-walk]" +[#337]: https://github.com/jprichardson/node-fs-extra/issues/337 "copy doesn't return a yieldable value" +[#336]: https://github.com/jprichardson/node-fs-extra/pull/336 "Docs enhanced walk sync [documentation, feature-walk]" +[#335]: https://github.com/jprichardson/node-fs-extra/pull/335 "Refactor move() tests [feature-move]" +[#334]: https://github.com/jprichardson/node-fs-extra/pull/334 "Cleanup lib/move/index.js [feature-move]" +[#333]: https://github.com/jprichardson/node-fs-extra/pull/333 "Rename clobber to overwrite [feature-copy, feature-move]" +[#332]: https://github.com/jprichardson/node-fs-extra/pull/332 "BREAKING: Drop Node v0.12 & io.js support" +[#331]: https://github.com/jprichardson/node-fs-extra/issues/331 "Add support for chmodr [enhancement, future]" +[#330]: https://github.com/jprichardson/node-fs-extra/pull/330 "BREAKING: Do not error when copy destination exists & clobber: false [feature-copy]" +[#329]: https://github.com/jprichardson/node-fs-extra/issues/329 "Does .walk() scale to large directories? [question]" +[#328]: https://github.com/jprichardson/node-fs-extra/issues/328 "Copying files corrupts [feature-copy, needs-confirmed]" +[#327]: https://github.com/jprichardson/node-fs-extra/pull/327 "Use writeStream 'finish' event instead of 'close' [bug, feature-copy]" +[#326]: https://github.com/jprichardson/node-fs-extra/issues/326 "fs.copy fails with chmod error when disk under heavy use [bug, feature-copy]" +[#325]: https://github.com/jprichardson/node-fs-extra/issues/325 "ensureDir is difficult to promisify [enhancement]" +[#324]: https://github.com/jprichardson/node-fs-extra/pull/324 "copySync() should apply filter to directories like copy() [bug, feature-copy]" +[#323]: https://github.com/jprichardson/node-fs-extra/issues/323 "Support for `dest` being a directory when using `copy*()`?" +[#322]: https://github.com/jprichardson/node-fs-extra/pull/322 "Add fs-promise as fs-extra-promise alternative" +[#321]: https://github.com/jprichardson/node-fs-extra/issues/321 "fs.copy() with clobber set to false return EEXIST error [feature-copy]" +[#320]: https://github.com/jprichardson/node-fs-extra/issues/320 "fs.copySync: Error: EPERM: operation not permitted, unlink " +[#319]: https://github.com/jprichardson/node-fs-extra/issues/319 "Create directory if not exists" +[#318]: https://github.com/jprichardson/node-fs-extra/issues/318 "Support glob patterns [enhancement, future]" +[#317]: https://github.com/jprichardson/node-fs-extra/pull/317 "Adding copy sync test for src file without write perms" +[#316]: https://github.com/jprichardson/node-fs-extra/pull/316 "Remove move()'s broken limit option [feature-move]" +[#315]: https://github.com/jprichardson/node-fs-extra/pull/315 "Fix move clobber tests to work around graceful-fs bug." +[#314]: https://github.com/jprichardson/node-fs-extra/issues/314 "move() limit option [documentation, enhancement, feature-move]" +[#313]: https://github.com/jprichardson/node-fs-extra/pull/313 "Test that remove() ignores glob characters." +[#312]: https://github.com/jprichardson/node-fs-extra/pull/312 "Enhance walkSync() to return items with path and stats [feature-walk]" +[#311]: https://github.com/jprichardson/node-fs-extra/issues/311 "move() not work when dest name not provided [feature-move]" +[#310]: https://github.com/jprichardson/node-fs-extra/issues/310 "Edit walkSync to return items like what walk emits [documentation, enhancement, feature-walk]" +[#309]: https://github.com/jprichardson/node-fs-extra/issues/309 "moveSync support [enhancement, feature-move]" +[#308]: https://github.com/jprichardson/node-fs-extra/pull/308 "Fix incorrect anchor link" +[#307]: https://github.com/jprichardson/node-fs-extra/pull/307 "Fix coverage" +[#306]: https://github.com/jprichardson/node-fs-extra/pull/306 "Update devDeps, fix lint error" +[#305]: https://github.com/jprichardson/node-fs-extra/pull/305 "Re-add Coveralls" +[#304]: https://github.com/jprichardson/node-fs-extra/pull/304 "Remove path-is-absolute [enhancement]" +[#303]: https://github.com/jprichardson/node-fs-extra/pull/303 "Document copySync filter inconsistency [documentation, feature-copy]" +[#302]: https://github.com/jprichardson/node-fs-extra/pull/302 "fix(console): depreciated -> deprecated" +[#301]: https://github.com/jprichardson/node-fs-extra/pull/301 "Remove chmod call from copySync [feature-copy]" +[#300]: https://github.com/jprichardson/node-fs-extra/pull/300 "Inline Rimraf [enhancement, feature-move, feature-remove]" +[#299]: https://github.com/jprichardson/node-fs-extra/pull/299 "Warn when filter is a RegExp [feature-copy]" +[#298]: https://github.com/jprichardson/node-fs-extra/issues/298 "API Docs [documentation]" +[#297]: https://github.com/jprichardson/node-fs-extra/pull/297 "Warn about using preserveTimestamps on 32-bit node" +[#296]: https://github.com/jprichardson/node-fs-extra/pull/296 "Improve EEXIST error message for copySync [enhancement]" +[#295]: https://github.com/jprichardson/node-fs-extra/pull/295 "Depreciate using regular expressions for copy's filter option [documentation]" +[#294]: https://github.com/jprichardson/node-fs-extra/pull/294 "BREAKING: Refactor lib/copy/ncp.js [feature-copy]" +[#293]: https://github.com/jprichardson/node-fs-extra/pull/293 "Update CI configs" +[#292]: https://github.com/jprichardson/node-fs-extra/issues/292 "Rewrite lib/copy/ncp.js [enhancement, feature-copy]" +[#291]: https://github.com/jprichardson/node-fs-extra/pull/291 "Escape '$' in replacement string for async file copying" +[#290]: https://github.com/jprichardson/node-fs-extra/issues/290 "Exclude files pattern while copying using copy.config.js [question]" +[#289]: https://github.com/jprichardson/node-fs-extra/pull/289 "(Closes #271) lib/util/utimes: properly close file descriptors in the event of an error" +[#288]: https://github.com/jprichardson/node-fs-extra/pull/288 "(Closes #271) lib/util/utimes: properly close file descriptors in the event of an error" +[#287]: https://github.com/jprichardson/node-fs-extra/issues/287 "emptyDir() callback arguments are inconsistent [enhancement, feature-remove]" +[#286]: https://github.com/jprichardson/node-fs-extra/pull/286 "Added walkSync function" +[#285]: https://github.com/jprichardson/node-fs-extra/issues/285 "CITGM test failing on s390" +[#284]: https://github.com/jprichardson/node-fs-extra/issues/284 "outputFile method is missing a check to determine if existing item is a folder or not" +[#283]: https://github.com/jprichardson/node-fs-extra/pull/283 "Apply filter also on directories and symlinks for copySync()" +[#282]: https://github.com/jprichardson/node-fs-extra/pull/282 "Apply filter also on directories and symlinks for copySync()" +[#281]: https://github.com/jprichardson/node-fs-extra/issues/281 "remove function executes 'successfully' but doesn't do anything?" +[#280]: https://github.com/jprichardson/node-fs-extra/pull/280 "Disable rimraf globbing" +[#279]: https://github.com/jprichardson/node-fs-extra/issues/279 "Some code is vendored instead of included [awaiting-reply]" +[#278]: https://github.com/jprichardson/node-fs-extra/issues/278 "copy() does not preserve file/directory ownership" +[#277]: https://github.com/jprichardson/node-fs-extra/pull/277 "Mention defaults for clobber and dereference options" +[#276]: https://github.com/jprichardson/node-fs-extra/issues/276 "Cannot connect to Shared Folder [awaiting-reply]" +[#275]: https://github.com/jprichardson/node-fs-extra/issues/275 "EMFILE, too many open files on Mac OS with JSON API" +[#274]: https://github.com/jprichardson/node-fs-extra/issues/274 "Use with memory-fs? [enhancement, future]" +[#273]: https://github.com/jprichardson/node-fs-extra/pull/273 "tests: rename `remote.test.js` to `remove.test.js`" +[#272]: https://github.com/jprichardson/node-fs-extra/issues/272 "Copy clobber flag never err even when true [bug, feature-copy]" +[#271]: https://github.com/jprichardson/node-fs-extra/issues/271 "Unclosed file handle on futimes error" +[#270]: https://github.com/jprichardson/node-fs-extra/issues/270 "copy not working as desired on Windows [feature-copy, platform-windows]" +[#269]: https://github.com/jprichardson/node-fs-extra/issues/269 "Copying with preserveTimeStamps: true is inaccurate using 32bit node [feature-copy]" +[#268]: https://github.com/jprichardson/node-fs-extra/pull/268 "port fix for mkdirp issue #111" +[#267]: https://github.com/jprichardson/node-fs-extra/issues/267 "WARN deprecated wrench@1.5.9: wrench.js is deprecated!" +[#266]: https://github.com/jprichardson/node-fs-extra/issues/266 "fs-extra" +[#265]: https://github.com/jprichardson/node-fs-extra/issues/265 "Link the `fs.stat fs.exists` etc. methods for replace the `fs` module forever?" +[#264]: https://github.com/jprichardson/node-fs-extra/issues/264 "Renaming a file using move fails when a file inside is open (at least on windows) [wont-fix]" +[#263]: https://github.com/jprichardson/node-fs-extra/issues/263 "ENOSYS: function not implemented, link [needs-confirmed]" +[#262]: https://github.com/jprichardson/node-fs-extra/issues/262 "Add .exists() and .existsSync()" +[#261]: https://github.com/jprichardson/node-fs-extra/issues/261 "Cannot read property 'prototype' of undefined" +[#260]: https://github.com/jprichardson/node-fs-extra/pull/260 "use more specific path for method require" +[#259]: https://github.com/jprichardson/node-fs-extra/issues/259 "Feature Request: isEmpty" +[#258]: https://github.com/jprichardson/node-fs-extra/issues/258 "copy files does not preserve file timestamp" +[#257]: https://github.com/jprichardson/node-fs-extra/issues/257 "Copying a file on windows fails" +[#256]: https://github.com/jprichardson/node-fs-extra/pull/256 "Updated Readme " +[#255]: https://github.com/jprichardson/node-fs-extra/issues/255 "Update rimraf required version" +[#254]: https://github.com/jprichardson/node-fs-extra/issues/254 "request for readTree, readTreeSync, walkSync method" +[#253]: https://github.com/jprichardson/node-fs-extra/issues/253 "outputFile does not touch mtime when file exists" +[#252]: https://github.com/jprichardson/node-fs-extra/pull/252 "Fixing problem when copying file with no write permission" +[#251]: https://github.com/jprichardson/node-fs-extra/issues/251 "Just wanted to say thank you" +[#250]: https://github.com/jprichardson/node-fs-extra/issues/250 "`fs.remove()` not removing files (works with `rm -rf`)" +[#249]: https://github.com/jprichardson/node-fs-extra/issues/249 "Just a Question ... Remove Servers" +[#248]: https://github.com/jprichardson/node-fs-extra/issues/248 "Allow option to not preserve permissions for copy" +[#247]: https://github.com/jprichardson/node-fs-extra/issues/247 "Add TypeScript typing directly in the fs-extra package" +[#246]: https://github.com/jprichardson/node-fs-extra/issues/246 "fse.remove() && fse.removeSync() don't throw error on ENOENT file" +[#245]: https://github.com/jprichardson/node-fs-extra/issues/245 "filter for empty dir [enhancement]" +[#244]: https://github.com/jprichardson/node-fs-extra/issues/244 "copySync doesn't apply the filter to directories" +[#243]: https://github.com/jprichardson/node-fs-extra/issues/243 "Can I request fs.walk() to be synchronous?" +[#242]: https://github.com/jprichardson/node-fs-extra/issues/242 "Accidentally truncates file names ending with $$ [bug, feature-copy]" +[#241]: https://github.com/jprichardson/node-fs-extra/pull/241 "Remove link to createOutputStream" +[#240]: https://github.com/jprichardson/node-fs-extra/issues/240 "walkSync request" +[#239]: https://github.com/jprichardson/node-fs-extra/issues/239 "Depreciate regular expressions for copy's filter [documentation, feature-copy]" +[#238]: https://github.com/jprichardson/node-fs-extra/issues/238 "Can't write to files while in a worker thread." +[#237]: https://github.com/jprichardson/node-fs-extra/issues/237 ".ensureDir(..) fails silently when passed an invalid path..." +[#236]: https://github.com/jprichardson/node-fs-extra/issues/236 "[Removed] Filed under wrong repo" +[#235]: https://github.com/jprichardson/node-fs-extra/pull/235 "Adds symlink dereference option to `fse.copySync` (#191)" +[#234]: https://github.com/jprichardson/node-fs-extra/issues/234 "ensureDirSync fails silent when EACCES: permission denied on travis-ci" +[#233]: https://github.com/jprichardson/node-fs-extra/issues/233 "please make sure the first argument in callback is error object [feature-copy]" +[#232]: https://github.com/jprichardson/node-fs-extra/issues/232 "Copy a folder content to its child folder. " +[#231]: https://github.com/jprichardson/node-fs-extra/issues/231 "Adding read/write/output functions for YAML" +[#230]: https://github.com/jprichardson/node-fs-extra/pull/230 "throw error if src and dest are the same to avoid zeroing out + test" +[#229]: https://github.com/jprichardson/node-fs-extra/pull/229 "fix 'TypeError: callback is not a function' in emptyDir" +[#228]: https://github.com/jprichardson/node-fs-extra/pull/228 "Throw error when target is empty so file is not accidentally zeroed out" +[#227]: https://github.com/jprichardson/node-fs-extra/issues/227 "Uncatchable errors when there are invalid arguments [feature-move]" +[#226]: https://github.com/jprichardson/node-fs-extra/issues/226 "Moving to the current directory" +[#225]: https://github.com/jprichardson/node-fs-extra/issues/225 "EBUSY: resource busy or locked, unlink" +[#224]: https://github.com/jprichardson/node-fs-extra/issues/224 "fse.copy ENOENT error" +[#223]: https://github.com/jprichardson/node-fs-extra/issues/223 "Suspicious behavior of fs.existsSync" +[#222]: https://github.com/jprichardson/node-fs-extra/pull/222 "A clearer description of emtpyDir function" +[#221]: https://github.com/jprichardson/node-fs-extra/pull/221 "Update README.md" +[#220]: https://github.com/jprichardson/node-fs-extra/pull/220 "Non-breaking feature: add option 'passStats' to copy methods." +[#219]: https://github.com/jprichardson/node-fs-extra/pull/219 "Add closing parenthesis in copySync example" +[#218]: https://github.com/jprichardson/node-fs-extra/pull/218 "fix #187 #70 options.filter bug" +[#217]: https://github.com/jprichardson/node-fs-extra/pull/217 "fix #187 #70 options.filter bug" +[#216]: https://github.com/jprichardson/node-fs-extra/pull/216 "fix #187 #70 options.filter bug" +[#215]: https://github.com/jprichardson/node-fs-extra/pull/215 "fse.copy throws error when only src and dest provided [bug, documentation, feature-copy]" +[#214]: https://github.com/jprichardson/node-fs-extra/pull/214 "Fixing copySync anchor tag" +[#213]: https://github.com/jprichardson/node-fs-extra/issues/213 "Merge extfs with this repo" +[#212]: https://github.com/jprichardson/node-fs-extra/pull/212 "Update year to 2016 in README.md and LICENSE" +[#211]: https://github.com/jprichardson/node-fs-extra/issues/211 "Not copying all files" +[#210]: https://github.com/jprichardson/node-fs-extra/issues/210 "copy/copySync behave differently when copying a symbolic file [bug, documentation, feature-copy]" +[#209]: https://github.com/jprichardson/node-fs-extra/issues/209 "In Windows invalid directory name causes infinite loop in ensureDir(). [bug]" +[#208]: https://github.com/jprichardson/node-fs-extra/pull/208 "fix options.preserveTimestamps to false in copy-sync by default [feature-copy]" +[#207]: https://github.com/jprichardson/node-fs-extra/issues/207 "Add `compare` suite of functions" +[#206]: https://github.com/jprichardson/node-fs-extra/issues/206 "outputFileSync" +[#205]: https://github.com/jprichardson/node-fs-extra/issues/205 "fix documents about copy/copySync [documentation, feature-copy]" +[#204]: https://github.com/jprichardson/node-fs-extra/pull/204 "allow copy of block and character device files" +[#203]: https://github.com/jprichardson/node-fs-extra/issues/203 "copy method's argument options couldn't be undefined [bug, feature-copy]" +[#202]: https://github.com/jprichardson/node-fs-extra/issues/202 "why there is not a walkSync method?" +[#201]: https://github.com/jprichardson/node-fs-extra/issues/201 "clobber for directories [feature-copy, future]" +[#200]: https://github.com/jprichardson/node-fs-extra/issues/200 "'copySync' doesn't work in sync" +[#199]: https://github.com/jprichardson/node-fs-extra/issues/199 "fs.copySync fails if user does not own file [bug, feature-copy]" +[#198]: https://github.com/jprichardson/node-fs-extra/issues/198 "handle copying between identical files [feature-copy]" +[#197]: https://github.com/jprichardson/node-fs-extra/issues/197 "Missing documentation for `outputFile` `options` 3rd parameter [documentation]" +[#196]: https://github.com/jprichardson/node-fs-extra/issues/196 "copy filter: async function and/or function called with `fs.stat` result [future]" +[#195]: https://github.com/jprichardson/node-fs-extra/issues/195 "How to override with outputFile?" +[#194]: https://github.com/jprichardson/node-fs-extra/pull/194 "allow ensureFile(Sync) to provide data to be written to created file" +[#193]: https://github.com/jprichardson/node-fs-extra/issues/193 "`fs.copy` fails silently if source file is /dev/null [bug, feature-copy]" +[#192]: https://github.com/jprichardson/node-fs-extra/issues/192 "Remove fs.createOutputStream()" +[#191]: https://github.com/jprichardson/node-fs-extra/issues/191 "How to copy symlinks to target as normal folders [feature-copy]" +[#190]: https://github.com/jprichardson/node-fs-extra/pull/190 "copySync to overwrite destination file if readonly and clobber true" +[#189]: https://github.com/jprichardson/node-fs-extra/pull/189 "move.test fix to support CRLF on Windows" +[#188]: https://github.com/jprichardson/node-fs-extra/issues/188 "move.test failing on windows platform" +[#187]: https://github.com/jprichardson/node-fs-extra/issues/187 "Not filter each file, stops on first false [feature-copy]" +[#186]: https://github.com/jprichardson/node-fs-extra/issues/186 "Do you need a .size() function in this module? [future]" +[#185]: https://github.com/jprichardson/node-fs-extra/issues/185 "Doesn't work on NodeJS v4.x" +[#184]: https://github.com/jprichardson/node-fs-extra/issues/184 "CLI equivalent for fs-extra" +[#183]: https://github.com/jprichardson/node-fs-extra/issues/183 "with clobber true, copy and copySync behave differently if destination file is read only [bug, feature-copy]" +[#182]: https://github.com/jprichardson/node-fs-extra/issues/182 "ensureDir(dir, callback) second callback parameter not specified" +[#181]: https://github.com/jprichardson/node-fs-extra/issues/181 "Add ability to remove file securely [enhancement, wont-fix]" +[#180]: https://github.com/jprichardson/node-fs-extra/issues/180 "Filter option doesn't work the same way in copy and copySync [bug, feature-copy]" +[#179]: https://github.com/jprichardson/node-fs-extra/issues/179 "Include opendir" +[#178]: https://github.com/jprichardson/node-fs-extra/issues/178 "ENOTEMPTY is thrown on removeSync " +[#177]: https://github.com/jprichardson/node-fs-extra/issues/177 "fix `remove()` wildcards (introduced by rimraf) [feature-remove]" +[#176]: https://github.com/jprichardson/node-fs-extra/issues/176 "createOutputStream doesn't emit 'end' event" +[#175]: https://github.com/jprichardson/node-fs-extra/issues/175 "[Feature Request].moveSync support [feature-move, future]" +[#174]: https://github.com/jprichardson/node-fs-extra/pull/174 "Fix copy formatting and document options.filter" +[#173]: https://github.com/jprichardson/node-fs-extra/issues/173 "Feature Request: writeJson should mkdirs" +[#172]: https://github.com/jprichardson/node-fs-extra/issues/172 "rename `clobber` flags to `overwrite`" +[#171]: https://github.com/jprichardson/node-fs-extra/issues/171 "remove unnecessary aliases" +[#170]: https://github.com/jprichardson/node-fs-extra/pull/170 "More robust handling of errors moving across virtual drives" +[#169]: https://github.com/jprichardson/node-fs-extra/pull/169 "suppress ensureLink & ensureSymlink dest exists error" +[#168]: https://github.com/jprichardson/node-fs-extra/pull/168 "suppress ensurelink dest exists error" +[#167]: https://github.com/jprichardson/node-fs-extra/pull/167 "Adds basic (string, buffer) support for ensureFile content [future]" +[#166]: https://github.com/jprichardson/node-fs-extra/pull/166 "Adds basic (string, buffer) support for ensureFile content" +[#165]: https://github.com/jprichardson/node-fs-extra/pull/165 "ensure for link & symlink" +[#164]: https://github.com/jprichardson/node-fs-extra/issues/164 "Feature Request: ensureFile to take optional argument for file content" +[#163]: https://github.com/jprichardson/node-fs-extra/issues/163 "ouputJson not formatted out of the box [bug]" +[#162]: https://github.com/jprichardson/node-fs-extra/pull/162 "ensure symlink & link" +[#161]: https://github.com/jprichardson/node-fs-extra/pull/161 "ensure symlink & link" +[#160]: https://github.com/jprichardson/node-fs-extra/pull/160 "ensure symlink & link" +[#159]: https://github.com/jprichardson/node-fs-extra/pull/159 "ensure symlink & link" +[#158]: https://github.com/jprichardson/node-fs-extra/issues/158 "Feature Request: ensureLink and ensureSymlink methods" +[#157]: https://github.com/jprichardson/node-fs-extra/issues/157 "writeJson isn't formatted" +[#156]: https://github.com/jprichardson/node-fs-extra/issues/156 "Promise.promisifyAll doesn't work for some methods" +[#155]: https://github.com/jprichardson/node-fs-extra/issues/155 "Readme" +[#154]: https://github.com/jprichardson/node-fs-extra/issues/154 "/tmp/millis-test-sync" +[#153]: https://github.com/jprichardson/node-fs-extra/pull/153 "Make preserveTimes also work on read-only files. Closes #152" +[#152]: https://github.com/jprichardson/node-fs-extra/issues/152 "fs.copy fails for read-only files with preserveTimestamp=true [feature-copy]" +[#151]: https://github.com/jprichardson/node-fs-extra/issues/151 "TOC does not work correctly on npm [documentation]" +[#150]: https://github.com/jprichardson/node-fs-extra/issues/150 "Remove test file fixtures, create with code." +[#149]: https://github.com/jprichardson/node-fs-extra/issues/149 "/tmp/millis-test-sync" +[#148]: https://github.com/jprichardson/node-fs-extra/issues/148 "split out `Sync` methods in documentation" +[#147]: https://github.com/jprichardson/node-fs-extra/issues/147 "Adding rmdirIfEmpty" +[#146]: https://github.com/jprichardson/node-fs-extra/pull/146 "ensure test.js works" +[#145]: https://github.com/jprichardson/node-fs-extra/issues/145 "Add `fs.exists` and `fs.existsSync` if it doesn't exist." +[#144]: https://github.com/jprichardson/node-fs-extra/issues/144 "tests failing" +[#143]: https://github.com/jprichardson/node-fs-extra/issues/143 "update graceful-fs" +[#142]: https://github.com/jprichardson/node-fs-extra/issues/142 "PrependFile Feature" +[#141]: https://github.com/jprichardson/node-fs-extra/pull/141 "Add option to preserve timestamps" +[#140]: https://github.com/jprichardson/node-fs-extra/issues/140 "Json file reading fails with 'utf8'" +[#139]: https://github.com/jprichardson/node-fs-extra/pull/139 "Preserve file timestamp on copy. Closes #138" +[#138]: https://github.com/jprichardson/node-fs-extra/issues/138 "Preserve timestamps on copying files" +[#137]: https://github.com/jprichardson/node-fs-extra/issues/137 "outputFile/outputJson: Unexpected end of input" +[#136]: https://github.com/jprichardson/node-fs-extra/pull/136 "Update license attribute" +[#135]: https://github.com/jprichardson/node-fs-extra/issues/135 "emptyDir throws Error if no callback is provided" +[#134]: https://github.com/jprichardson/node-fs-extra/pull/134 "Handle EEXIST error when clobbering dir" +[#133]: https://github.com/jprichardson/node-fs-extra/pull/133 "Travis runs with `sudo: false`" +[#132]: https://github.com/jprichardson/node-fs-extra/pull/132 "isDirectory method" +[#131]: https://github.com/jprichardson/node-fs-extra/issues/131 "copySync is not working iojs 1.8.4 on linux [feature-copy]" +[#130]: https://github.com/jprichardson/node-fs-extra/pull/130 "Please review additional features." +[#129]: https://github.com/jprichardson/node-fs-extra/pull/129 "can you review this feature?" +[#128]: https://github.com/jprichardson/node-fs-extra/issues/128 "fsExtra.move(filepath, newPath) broken;" +[#127]: https://github.com/jprichardson/node-fs-extra/issues/127 "consider using fs.access to remove deprecated warnings for fs.exists" +[#126]: https://github.com/jprichardson/node-fs-extra/issues/126 " TypeError: Object # has no method 'access'" +[#125]: https://github.com/jprichardson/node-fs-extra/issues/125 "Question: What do the *Sync function do different from non-sync" +[#124]: https://github.com/jprichardson/node-fs-extra/issues/124 "move with clobber option 'ENOTEMPTY'" +[#123]: https://github.com/jprichardson/node-fs-extra/issues/123 "Only copy the content of a directory" +[#122]: https://github.com/jprichardson/node-fs-extra/pull/122 "Update section links in README to match current section ids." +[#121]: https://github.com/jprichardson/node-fs-extra/issues/121 "emptyDir is undefined" +[#120]: https://github.com/jprichardson/node-fs-extra/issues/120 "usage bug caused by shallow cloning methods of 'graceful-fs'" +[#119]: https://github.com/jprichardson/node-fs-extra/issues/119 "mkdirs and ensureDir never invoke callback and consume CPU indefinitely if provided a path with invalid characters on Windows" +[#118]: https://github.com/jprichardson/node-fs-extra/pull/118 "createOutputStream" +[#117]: https://github.com/jprichardson/node-fs-extra/pull/117 "Fixed issue with slash separated paths on windows" +[#116]: https://github.com/jprichardson/node-fs-extra/issues/116 "copySync can only copy directories not files [documentation, feature-copy]" +[#115]: https://github.com/jprichardson/node-fs-extra/issues/115 ".Copy & .CopySync [feature-copy]" +[#114]: https://github.com/jprichardson/node-fs-extra/issues/114 "Fails to move (rename) directory to non-empty directory even with clobber: true" +[#113]: https://github.com/jprichardson/node-fs-extra/issues/113 "fs.copy seems to callback early if the destination file already exists" +[#112]: https://github.com/jprichardson/node-fs-extra/pull/112 "Copying a file into an existing directory" +[#111]: https://github.com/jprichardson/node-fs-extra/pull/111 "Moving a file into an existing directory " +[#110]: https://github.com/jprichardson/node-fs-extra/pull/110 "Moving a file into an existing directory" +[#109]: https://github.com/jprichardson/node-fs-extra/issues/109 "fs.move across windows drives fails" +[#108]: https://github.com/jprichardson/node-fs-extra/issues/108 "fse.move directories across multiple devices doesn't work" +[#107]: https://github.com/jprichardson/node-fs-extra/pull/107 "Check if dest path is an existing dir and copy or move source in it" +[#106]: https://github.com/jprichardson/node-fs-extra/issues/106 "fse.copySync crashes while copying across devices D: [feature-copy]" +[#105]: https://github.com/jprichardson/node-fs-extra/issues/105 "fs.copy hangs on iojs" +[#104]: https://github.com/jprichardson/node-fs-extra/issues/104 "fse.move deletes folders [bug]" +[#103]: https://github.com/jprichardson/node-fs-extra/issues/103 "Error: EMFILE with copy" +[#102]: https://github.com/jprichardson/node-fs-extra/issues/102 "touch / touchSync was removed ?" +[#101]: https://github.com/jprichardson/node-fs-extra/issues/101 "fs-extra promisified" +[#100]: https://github.com/jprichardson/node-fs-extra/pull/100 "copy: options object or filter to pass to ncp" +[#99]: https://github.com/jprichardson/node-fs-extra/issues/99 "ensureDir() modes [future]" +[#98]: https://github.com/jprichardson/node-fs-extra/issues/98 "fs.copy() incorrect async behavior [bug]" +[#97]: https://github.com/jprichardson/node-fs-extra/pull/97 "use path.join; fix copySync bug" +[#96]: https://github.com/jprichardson/node-fs-extra/issues/96 "destFolderExists in copySync is always undefined." +[#95]: https://github.com/jprichardson/node-fs-extra/pull/95 "Using graceful-ncp instead of ncp" +[#94]: https://github.com/jprichardson/node-fs-extra/issues/94 "Error: EEXIST, file already exists '../mkdirp/bin/cmd.js' on fs.copySync() [enhancement, feature-copy]" +[#93]: https://github.com/jprichardson/node-fs-extra/issues/93 "Confusing error if drive not mounted [enhancement]" +[#92]: https://github.com/jprichardson/node-fs-extra/issues/92 "Problems with Bluebird" +[#91]: https://github.com/jprichardson/node-fs-extra/issues/91 "fs.copySync('/test', '/haha') is different with 'cp -r /test /haha' [enhancement]" +[#90]: https://github.com/jprichardson/node-fs-extra/issues/90 "Folder creation and file copy is Happening in 64 bit machine but not in 32 bit machine" +[#89]: https://github.com/jprichardson/node-fs-extra/issues/89 "Error: EEXIST using fs-extra's fs.copy to copy a directory on Windows" +[#88]: https://github.com/jprichardson/node-fs-extra/issues/88 "Stacking those libraries" +[#87]: https://github.com/jprichardson/node-fs-extra/issues/87 "createWriteStream + outputFile = ?" +[#86]: https://github.com/jprichardson/node-fs-extra/issues/86 "no moveSync?" +[#85]: https://github.com/jprichardson/node-fs-extra/pull/85 "Copy symlinks in copySync" +[#84]: https://github.com/jprichardson/node-fs-extra/issues/84 "Push latest version to npm ?" +[#83]: https://github.com/jprichardson/node-fs-extra/issues/83 "Prevent copying a directory into itself [feature-copy]" +[#82]: https://github.com/jprichardson/node-fs-extra/pull/82 "README updates for move" +[#81]: https://github.com/jprichardson/node-fs-extra/issues/81 "fd leak after fs.move" +[#80]: https://github.com/jprichardson/node-fs-extra/pull/80 "Preserve file mode in copySync" +[#79]: https://github.com/jprichardson/node-fs-extra/issues/79 "fs.copy only .html file empty" +[#78]: https://github.com/jprichardson/node-fs-extra/pull/78 "copySync was not applying filters to directories" +[#77]: https://github.com/jprichardson/node-fs-extra/issues/77 "Create README reference to bluebird" +[#76]: https://github.com/jprichardson/node-fs-extra/issues/76 "Create README reference to typescript" +[#75]: https://github.com/jprichardson/node-fs-extra/issues/75 "add glob as a dep? [question]" +[#74]: https://github.com/jprichardson/node-fs-extra/pull/74 "including new emptydir module" +[#73]: https://github.com/jprichardson/node-fs-extra/pull/73 "add dependency status in readme" +[#72]: https://github.com/jprichardson/node-fs-extra/pull/72 "Use svg instead of png to get better image quality" +[#71]: https://github.com/jprichardson/node-fs-extra/issues/71 "fse.copy not working on Windows 7 x64 OS, but, copySync does work" +[#70]: https://github.com/jprichardson/node-fs-extra/issues/70 "Not filter each file, stops on first false [bug]" +[#69]: https://github.com/jprichardson/node-fs-extra/issues/69 "How to check if folder exist and read the folder name" +[#68]: https://github.com/jprichardson/node-fs-extra/issues/68 "consider flag to readJsonSync (throw false) [enhancement]" +[#67]: https://github.com/jprichardson/node-fs-extra/issues/67 "docs for readJson incorrectly states that is accepts options" +[#66]: https://github.com/jprichardson/node-fs-extra/issues/66 "ENAMETOOLONG" +[#65]: https://github.com/jprichardson/node-fs-extra/issues/65 "exclude filter in fs.copy" +[#64]: https://github.com/jprichardson/node-fs-extra/issues/64 "Announce: mfs - monitor your fs-extra calls" +[#63]: https://github.com/jprichardson/node-fs-extra/issues/63 "Walk" +[#62]: https://github.com/jprichardson/node-fs-extra/issues/62 "npm install fs-extra doesn't work" +[#61]: https://github.com/jprichardson/node-fs-extra/issues/61 "No longer supports node 0.8 due to use of `^` in package.json dependencies" +[#60]: https://github.com/jprichardson/node-fs-extra/issues/60 "chmod & chown for mkdirs" +[#59]: https://github.com/jprichardson/node-fs-extra/issues/59 "Consider including mkdirp and making fs-extra '--use_strict' safe [question]" +[#58]: https://github.com/jprichardson/node-fs-extra/issues/58 "Stack trace not included in fs.copy error" +[#57]: https://github.com/jprichardson/node-fs-extra/issues/57 "Possible to include wildcards in delete?" +[#56]: https://github.com/jprichardson/node-fs-extra/issues/56 "Crash when have no access to write to destination file in copy " +[#55]: https://github.com/jprichardson/node-fs-extra/issues/55 "Is it possible to have any console output similar to Grunt copy module?" +[#54]: https://github.com/jprichardson/node-fs-extra/issues/54 "`copy` does not preserve file ownership and permissons" +[#53]: https://github.com/jprichardson/node-fs-extra/issues/53 "outputFile() - ability to write data in appending mode" +[#52]: https://github.com/jprichardson/node-fs-extra/pull/52 "This fixes (what I think) is a bug in copySync" +[#51]: https://github.com/jprichardson/node-fs-extra/pull/51 "Add a Bitdeli Badge to README" +[#50]: https://github.com/jprichardson/node-fs-extra/issues/50 "Replace mechanism in createFile" +[#49]: https://github.com/jprichardson/node-fs-extra/pull/49 "update rimraf to v2.2.6" +[#48]: https://github.com/jprichardson/node-fs-extra/issues/48 "fs.copy issue [bug]" +[#47]: https://github.com/jprichardson/node-fs-extra/issues/47 "Bug in copy - callback called on readStream 'close' - Fixed in ncp 0.5.0" +[#46]: https://github.com/jprichardson/node-fs-extra/pull/46 "update copyright year" +[#45]: https://github.com/jprichardson/node-fs-extra/pull/45 "Added note about fse.outputFile() being the one that overwrites" +[#44]: https://github.com/jprichardson/node-fs-extra/pull/44 "Proposal: Stream support" +[#43]: https://github.com/jprichardson/node-fs-extra/issues/43 "Better error reporting " +[#42]: https://github.com/jprichardson/node-fs-extra/issues/42 "Performance issue?" +[#41]: https://github.com/jprichardson/node-fs-extra/pull/41 "There does seem to be a synchronous version now" +[#40]: https://github.com/jprichardson/node-fs-extra/issues/40 "fs.copy throw unexplained error ENOENT, utime " +[#39]: https://github.com/jprichardson/node-fs-extra/pull/39 "Added regression test for copy() return callback on error" +[#38]: https://github.com/jprichardson/node-fs-extra/pull/38 "Return err in copy() fstat cb, because stat could be undefined or null" +[#37]: https://github.com/jprichardson/node-fs-extra/issues/37 "Maybe include a line reader? [enhancement, question]" +[#36]: https://github.com/jprichardson/node-fs-extra/pull/36 "`filter` parameter `fs.copy` and `fs.copySync`" +[#35]: https://github.com/jprichardson/node-fs-extra/pull/35 "`filter` parameter `fs.copy` and `fs.copySync` " +[#34]: https://github.com/jprichardson/node-fs-extra/issues/34 "update docs to include options for JSON methods [enhancement]" +[#33]: https://github.com/jprichardson/node-fs-extra/pull/33 "fs_extra.copySync" +[#32]: https://github.com/jprichardson/node-fs-extra/issues/32 "update to latest jsonfile [enhancement]" +[#31]: https://github.com/jprichardson/node-fs-extra/issues/31 "Add ensure methods [enhancement]" +[#30]: https://github.com/jprichardson/node-fs-extra/issues/30 "update package.json optional dep `graceful-fs`" +[#29]: https://github.com/jprichardson/node-fs-extra/issues/29 "Copy failing if dest directory doesn't exist. Is this intended?" +[#28]: https://github.com/jprichardson/node-fs-extra/issues/28 "homepage field must be a string url. Deleted." +[#27]: https://github.com/jprichardson/node-fs-extra/issues/27 "Update Readme" +[#26]: https://github.com/jprichardson/node-fs-extra/issues/26 "Add readdir recursive method. [enhancement]" +[#25]: https://github.com/jprichardson/node-fs-extra/pull/25 "adding an `.npmignore` file" +[#24]: https://github.com/jprichardson/node-fs-extra/issues/24 "[bug] cannot run in strict mode [bug]" +[#23]: https://github.com/jprichardson/node-fs-extra/issues/23 "`writeJSON()` should create parent directories" +[#22]: https://github.com/jprichardson/node-fs-extra/pull/22 "Add a limit option to mkdirs()" +[#21]: https://github.com/jprichardson/node-fs-extra/issues/21 "touch() in 0.10.0" +[#20]: https://github.com/jprichardson/node-fs-extra/issues/20 "fs.remove yields callback before directory is really deleted" +[#19]: https://github.com/jprichardson/node-fs-extra/issues/19 "fs.copy err is empty array" +[#18]: https://github.com/jprichardson/node-fs-extra/pull/18 "Exposed copyFile Function" +[#17]: https://github.com/jprichardson/node-fs-extra/issues/17 "Use `require('graceful-fs')` if found instead of `require('fs')`" +[#16]: https://github.com/jprichardson/node-fs-extra/pull/16 "Update README.md" +[#15]: https://github.com/jprichardson/node-fs-extra/issues/15 "Implement cp -r but sync aka copySync. [enhancement]" +[#14]: https://github.com/jprichardson/node-fs-extra/issues/14 "fs.mkdirSync is broken in 0.3.1" +[#13]: https://github.com/jprichardson/node-fs-extra/issues/13 "Thoughts on including a directory tree / file watcher? [enhancement, question]" +[#12]: https://github.com/jprichardson/node-fs-extra/issues/12 "copyFile & copyFileSync are global" +[#11]: https://github.com/jprichardson/node-fs-extra/issues/11 "Thoughts on including a file walker? [enhancement, question]" +[#10]: https://github.com/jprichardson/node-fs-extra/issues/10 "move / moveFile API [enhancement]" +[#9]: https://github.com/jprichardson/node-fs-extra/issues/9 "don't import normal fs stuff into fs-extra" +[#8]: https://github.com/jprichardson/node-fs-extra/pull/8 "Update rimraf to latest version" +[#6]: https://github.com/jprichardson/node-fs-extra/issues/6 "Remove CoffeeScript development dependency" +[#5]: https://github.com/jprichardson/node-fs-extra/issues/5 "comments on naming" +[#4]: https://github.com/jprichardson/node-fs-extra/issues/4 "version bump to 0.2" +[#3]: https://github.com/jprichardson/node-fs-extra/pull/3 "Hi! I fixed some code for you!" +[#2]: https://github.com/jprichardson/node-fs-extra/issues/2 "Merge with fs.extra and mkdirp" +[#1]: https://github.com/jprichardson/node-fs-extra/issues/1 "file-extra npm !exist" diff --git a/tools/ui/node_modules/fs-extra/LICENSE b/tools/ui/node_modules/fs-extra/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..93546dfb7655bfafd17a87ab7f3391c9e68f4130 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/LICENSE @@ -0,0 +1,15 @@ +(The MIT License) + +Copyright (c) 2011-2017 JP Richardson + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files +(the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, + merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS +OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/fs-extra/README.md b/tools/ui/node_modules/fs-extra/README.md new file mode 100644 index 0000000000000000000000000000000000000000..b4a5370b4ae615df9435c8c12aad28236a4da587 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/README.md @@ -0,0 +1,264 @@ +Node.js: fs-extra +================= + +`fs-extra` adds file system methods that aren't included in the native `fs` module and adds promise support to the `fs` methods. It also uses [`graceful-fs`](https://github.com/isaacs/node-graceful-fs) to prevent `EMFILE` errors. It should be a drop in replacement for `fs`. + +[![npm Package](https://img.shields.io/npm/v/fs-extra.svg)](https://www.npmjs.org/package/fs-extra) +[![License](https://img.shields.io/npm/l/express.svg)](https://github.com/jprichardson/node-fs-extra/blob/master/LICENSE) +[![build status](https://img.shields.io/travis/jprichardson/node-fs-extra/master.svg)](http://travis-ci.org/jprichardson/node-fs-extra) +[![windows Build status](https://img.shields.io/appveyor/ci/jprichardson/node-fs-extra/master.svg?label=windows%20build)](https://ci.appveyor.com/project/jprichardson/node-fs-extra/branch/master) +[![downloads per month](http://img.shields.io/npm/dm/fs-extra.svg)](https://www.npmjs.org/package/fs-extra) +[![Coverage Status](https://img.shields.io/coveralls/github/jprichardson/node-fs-extra/master.svg)](https://coveralls.io/github/jprichardson/node-fs-extra) +[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com) + +Why? +---- + +I got tired of including `mkdirp`, `rimraf`, and `ncp` in most of my projects. + + + + +Installation +------------ + + npm install fs-extra + + + +Usage +----- + +`fs-extra` is a drop in replacement for native `fs`. All methods in `fs` are attached to `fs-extra`. All `fs` methods return promises if the callback isn't passed. + +You don't ever need to include the original `fs` module again: + +```js +const fs = require('fs') // this is no longer necessary +``` + +you can now do this: + +```js +const fs = require('fs-extra') +``` + +or if you prefer to make it clear that you're using `fs-extra` and not `fs`, you may want +to name your `fs` variable `fse` like so: + +```js +const fse = require('fs-extra') +``` + +you can also keep both, but it's redundant: + +```js +const fs = require('fs') +const fse = require('fs-extra') +``` + +Sync vs Async vs Async/Await +------------- +Most methods are async by default. All async methods will return a promise if the callback isn't passed. + +Sync methods on the other hand will throw if an error occurs. + +Also Async/Await will throw an error if one occurs. + +Example: + +```js +const fs = require('fs-extra') + +// Async with promises: +fs.copy('/tmp/myfile', '/tmp/mynewfile') + .then(() => console.log('success!')) + .catch(err => console.error(err)) + +// Async with callbacks: +fs.copy('/tmp/myfile', '/tmp/mynewfile', err => { + if (err) return console.error(err) + console.log('success!') +}) + +// Sync: +try { + fs.copySync('/tmp/myfile', '/tmp/mynewfile') + console.log('success!') +} catch (err) { + console.error(err) +} + +// Async/Await: +async function copyFiles () { + try { + await fs.copy('/tmp/myfile', '/tmp/mynewfile') + console.log('success!') + } catch (err) { + console.error(err) + } +} + +copyFiles() +``` + + +Methods +------- + +### Async + +- [copy](docs/copy.md) +- [emptyDir](docs/emptyDir.md) +- [ensureFile](docs/ensureFile.md) +- [ensureDir](docs/ensureDir.md) +- [ensureLink](docs/ensureLink.md) +- [ensureSymlink](docs/ensureSymlink.md) +- [mkdirp](docs/ensureDir.md) +- [mkdirs](docs/ensureDir.md) +- [move](docs/move.md) +- [outputFile](docs/outputFile.md) +- [outputJson](docs/outputJson.md) +- [pathExists](docs/pathExists.md) +- [readJson](docs/readJson.md) +- [remove](docs/remove.md) +- [writeJson](docs/writeJson.md) + +### Sync + +- [copySync](docs/copy-sync.md) +- [emptyDirSync](docs/emptyDir-sync.md) +- [ensureFileSync](docs/ensureFile-sync.md) +- [ensureDirSync](docs/ensureDir-sync.md) +- [ensureLinkSync](docs/ensureLink-sync.md) +- [ensureSymlinkSync](docs/ensureSymlink-sync.md) +- [mkdirpSync](docs/ensureDir-sync.md) +- [mkdirsSync](docs/ensureDir-sync.md) +- [moveSync](docs/move-sync.md) +- [outputFileSync](docs/outputFile-sync.md) +- [outputJsonSync](docs/outputJson-sync.md) +- [pathExistsSync](docs/pathExists-sync.md) +- [readJsonSync](docs/readJson-sync.md) +- [removeSync](docs/remove-sync.md) +- [writeJsonSync](docs/writeJson-sync.md) + + +**NOTE:** You can still use the native Node.js methods. They are promisified and copied over to `fs-extra`. See [notes on `fs.read()`, `fs.write()`, & `fs.writev()`](docs/fs-read-write-writev.md) + +### What happened to `walk()` and `walkSync()`? + +They were removed from `fs-extra` in v2.0.0. If you need the functionality, `walk` and `walkSync` are available as separate packages, [`klaw`](https://github.com/jprichardson/node-klaw) and [`klaw-sync`](https://github.com/manidlou/node-klaw-sync). + + +Third Party +----------- + +### CLI + +[fse-cli](https://www.npmjs.com/package/@atao60/fse-cli) allows you to run `fs-extra` from a console or from [npm](https://www.npmjs.com) scripts. + +### TypeScript + +If you like TypeScript, you can use `fs-extra` with it: https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/fs-extra + + +### File / Directory Watching + +If you want to watch for changes to files or directories, then you should use [chokidar](https://github.com/paulmillr/chokidar). + +### Obtain Filesystem (Devices, Partitions) Information + +[fs-filesystem](https://github.com/arthurintelligence/node-fs-filesystem) allows you to read the state of the filesystem of the host on which it is run. It returns information about both the devices and the partitions (volumes) of the system. + +### Misc. + +- [fs-extra-debug](https://github.com/jdxcode/fs-extra-debug) - Send your fs-extra calls to [debug](https://npmjs.org/package/debug). +- [mfs](https://github.com/cadorn/mfs) - Monitor your fs-extra calls. + + + +Hacking on fs-extra +------------------- + +Wanna hack on `fs-extra`? Great! Your help is needed! [fs-extra is one of the most depended upon Node.js packages](http://nodei.co/npm/fs-extra.png?downloads=true&downloadRank=true&stars=true). This project +uses [JavaScript Standard Style](https://github.com/feross/standard) - if the name or style choices bother you, +you're gonna have to get over it :) If `standard` is good enough for `npm`, it's good enough for `fs-extra`. + +[![js-standard-style](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard) + +What's needed? +- First, take a look at existing issues. Those are probably going to be where the priority lies. +- More tests for edge cases. Specifically on different platforms. There can never be enough tests. +- Improve test coverage. See coveralls output for more info. + +Note: If you make any big changes, **you should definitely file an issue for discussion first.** + +### Running the Test Suite + +fs-extra contains hundreds of tests. + +- `npm run lint`: runs the linter ([standard](http://standardjs.com/)) +- `npm run unit`: runs the unit tests +- `npm test`: runs both the linter and the tests + + +### Windows + +If you run the tests on the Windows and receive a lot of symbolic link `EPERM` permission errors, it's +because on Windows you need elevated privilege to create symbolic links. You can add this to your Windows's +account by following the instructions here: http://superuser.com/questions/104845/permission-to-make-symbolic-links-in-windows-7 +However, I didn't have much luck doing this. + +Since I develop on Mac OS X, I use VMWare Fusion for Windows testing. I create a shared folder that I map to a drive on Windows. +I open the `Node.js command prompt` and run as `Administrator`. I then map the network drive running the following command: + + net use z: "\\vmware-host\Shared Folders" + +I can then navigate to my `fs-extra` directory and run the tests. + + +Naming +------ + +I put a lot of thought into the naming of these functions. Inspired by @coolaj86's request. So he deserves much of the credit for raising the issue. See discussion(s) here: + +* https://github.com/jprichardson/node-fs-extra/issues/2 +* https://github.com/flatiron/utile/issues/11 +* https://github.com/ryanmcgrath/wrench-js/issues/29 +* https://github.com/substack/node-mkdirp/issues/17 + +First, I believe that in as many cases as possible, the [Node.js naming schemes](http://nodejs.org/api/fs.html) should be chosen. However, there are problems with the Node.js own naming schemes. + +For example, `fs.readFile()` and `fs.readdir()`: the **F** is capitalized in *File* and the **d** is not capitalized in *dir*. Perhaps a bit pedantic, but they should still be consistent. Also, Node.js has chosen a lot of POSIX naming schemes, which I believe is great. See: `fs.mkdir()`, `fs.rmdir()`, `fs.chown()`, etc. + +We have a dilemma though. How do you consistently name methods that perform the following POSIX commands: `cp`, `cp -r`, `mkdir -p`, and `rm -rf`? + +My perspective: when in doubt, err on the side of simplicity. A directory is just a hierarchical grouping of directories and files. Consider that for a moment. So when you want to copy it or remove it, in most cases you'll want to copy or remove all of its contents. When you want to create a directory, if the directory that it's suppose to be contained in does not exist, then in most cases you'll want to create that too. + +So, if you want to remove a file or a directory regardless of whether it has contents, just call `fs.remove(path)`. If you want to copy a file or a directory whether it has contents, just call `fs.copy(source, destination)`. If you want to create a directory regardless of whether its parent directories exist, just call `fs.mkdirs(path)` or `fs.mkdirp(path)`. + + +Credit +------ + +`fs-extra` wouldn't be possible without using the modules from the following authors: + +- [Isaac Shlueter](https://github.com/isaacs) +- [Charlie McConnel](https://github.com/avianflu) +- [James Halliday](https://github.com/substack) +- [Andrew Kelley](https://github.com/andrewrk) + + + + +License +------- + +Licensed under MIT + +Copyright (c) 2011-2017 [JP Richardson](https://github.com/jprichardson) + +[1]: http://nodejs.org/docs/latest/api/fs.html + + +[jsonfile]: https://github.com/jprichardson/node-jsonfile diff --git a/tools/ui/node_modules/fs-extra/lib/copy-sync/copy-sync.js b/tools/ui/node_modules/fs-extra/lib/copy-sync/copy-sync.js new file mode 100644 index 0000000000000000000000000000000000000000..31f06e4419d91c8b78e2c7210605173939a3ba93 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/copy-sync/copy-sync.js @@ -0,0 +1,166 @@ +'use strict' + +const fs = require('graceful-fs') +const path = require('path') +const mkdirsSync = require('../mkdirs').mkdirsSync +const utimesMillisSync = require('../util/utimes').utimesMillisSync +const stat = require('../util/stat') + +function copySync (src, dest, opts) { + if (typeof opts === 'function') { + opts = { filter: opts } + } + + opts = opts || {} + opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now + opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber + + // Warn about using preserveTimestamps on 32-bit node + if (opts.preserveTimestamps && process.arch === 'ia32') { + console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n + see https://github.com/jprichardson/node-fs-extra/issues/269`) + } + + const { srcStat, destStat } = stat.checkPathsSync(src, dest, 'copy') + stat.checkParentPathsSync(src, srcStat, dest, 'copy') + return handleFilterAndCopy(destStat, src, dest, opts) +} + +function handleFilterAndCopy (destStat, src, dest, opts) { + if (opts.filter && !opts.filter(src, dest)) return + const destParent = path.dirname(dest) + if (!fs.existsSync(destParent)) mkdirsSync(destParent) + return startCopy(destStat, src, dest, opts) +} + +function startCopy (destStat, src, dest, opts) { + if (opts.filter && !opts.filter(src, dest)) return + return getStats(destStat, src, dest, opts) +} + +function getStats (destStat, src, dest, opts) { + const statSync = opts.dereference ? fs.statSync : fs.lstatSync + const srcStat = statSync(src) + + if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts) + else if (srcStat.isFile() || + srcStat.isCharacterDevice() || + srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts) + else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts) +} + +function onFile (srcStat, destStat, src, dest, opts) { + if (!destStat) return copyFile(srcStat, src, dest, opts) + return mayCopyFile(srcStat, src, dest, opts) +} + +function mayCopyFile (srcStat, src, dest, opts) { + if (opts.overwrite) { + fs.unlinkSync(dest) + return copyFile(srcStat, src, dest, opts) + } else if (opts.errorOnExist) { + throw new Error(`'${dest}' already exists`) + } +} + +function copyFile (srcStat, src, dest, opts) { + fs.copyFileSync(src, dest) + if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest) + return setDestMode(dest, srcStat.mode) +} + +function handleTimestamps (srcMode, src, dest) { + // Make sure the file is writable before setting the timestamp + // otherwise open fails with EPERM when invoked with 'r+' + // (through utimes call) + if (fileIsNotWritable(srcMode)) makeFileWritable(dest, srcMode) + return setDestTimestamps(src, dest) +} + +function fileIsNotWritable (srcMode) { + return (srcMode & 0o200) === 0 +} + +function makeFileWritable (dest, srcMode) { + return setDestMode(dest, srcMode | 0o200) +} + +function setDestMode (dest, srcMode) { + return fs.chmodSync(dest, srcMode) +} + +function setDestTimestamps (src, dest) { + // The initial srcStat.atime cannot be trusted + // because it is modified by the read(2) system call + // (See https://nodejs.org/api/fs.html#fs_stat_time_values) + const updatedSrcStat = fs.statSync(src) + return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime) +} + +function onDir (srcStat, destStat, src, dest, opts) { + if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts) + if (destStat && !destStat.isDirectory()) { + throw new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`) + } + return copyDir(src, dest, opts) +} + +function mkDirAndCopy (srcMode, src, dest, opts) { + fs.mkdirSync(dest) + copyDir(src, dest, opts) + return setDestMode(dest, srcMode) +} + +function copyDir (src, dest, opts) { + fs.readdirSync(src).forEach(item => copyDirItem(item, src, dest, opts)) +} + +function copyDirItem (item, src, dest, opts) { + const srcItem = path.join(src, item) + const destItem = path.join(dest, item) + const { destStat } = stat.checkPathsSync(srcItem, destItem, 'copy') + return startCopy(destStat, srcItem, destItem, opts) +} + +function onLink (destStat, src, dest, opts) { + let resolvedSrc = fs.readlinkSync(src) + if (opts.dereference) { + resolvedSrc = path.resolve(process.cwd(), resolvedSrc) + } + + if (!destStat) { + return fs.symlinkSync(resolvedSrc, dest) + } else { + let resolvedDest + try { + resolvedDest = fs.readlinkSync(dest) + } catch (err) { + // dest exists and is a regular file or directory, + // Windows may throw UNKNOWN error. If dest already exists, + // fs throws error anyway, so no need to guard against it here. + if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlinkSync(resolvedSrc, dest) + throw err + } + if (opts.dereference) { + resolvedDest = path.resolve(process.cwd(), resolvedDest) + } + if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) { + throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`) + } + + // prevent copy if src is a subdir of dest since unlinking + // dest in this case would result in removing src contents + // and therefore a broken symlink would be created. + if (fs.statSync(dest).isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) { + throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`) + } + return copyLink(resolvedSrc, dest) + } +} + +function copyLink (resolvedSrc, dest) { + fs.unlinkSync(dest) + return fs.symlinkSync(resolvedSrc, dest) +} + +module.exports = copySync diff --git a/tools/ui/node_modules/fs-extra/lib/copy-sync/index.js b/tools/ui/node_modules/fs-extra/lib/copy-sync/index.js new file mode 100644 index 0000000000000000000000000000000000000000..65945aedb20a3648a63cf70d98a07e193296f455 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/copy-sync/index.js @@ -0,0 +1,5 @@ +'use strict' + +module.exports = { + copySync: require('./copy-sync') +} diff --git a/tools/ui/node_modules/fs-extra/lib/copy/copy.js b/tools/ui/node_modules/fs-extra/lib/copy/copy.js new file mode 100644 index 0000000000000000000000000000000000000000..328f1025f9b5054a0e727c3a462a0797433d7b0c --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/copy/copy.js @@ -0,0 +1,232 @@ +'use strict' + +const fs = require('graceful-fs') +const path = require('path') +const mkdirs = require('../mkdirs').mkdirs +const pathExists = require('../path-exists').pathExists +const utimesMillis = require('../util/utimes').utimesMillis +const stat = require('../util/stat') + +function copy (src, dest, opts, cb) { + if (typeof opts === 'function' && !cb) { + cb = opts + opts = {} + } else if (typeof opts === 'function') { + opts = { filter: opts } + } + + cb = cb || function () {} + opts = opts || {} + + opts.clobber = 'clobber' in opts ? !!opts.clobber : true // default to true for now + opts.overwrite = 'overwrite' in opts ? !!opts.overwrite : opts.clobber // overwrite falls back to clobber + + // Warn about using preserveTimestamps on 32-bit node + if (opts.preserveTimestamps && process.arch === 'ia32') { + console.warn(`fs-extra: Using the preserveTimestamps option in 32-bit node is not recommended;\n + see https://github.com/jprichardson/node-fs-extra/issues/269`) + } + + stat.checkPaths(src, dest, 'copy', (err, stats) => { + if (err) return cb(err) + const { srcStat, destStat } = stats + stat.checkParentPaths(src, srcStat, dest, 'copy', err => { + if (err) return cb(err) + if (opts.filter) return handleFilter(checkParentDir, destStat, src, dest, opts, cb) + return checkParentDir(destStat, src, dest, opts, cb) + }) + }) +} + +function checkParentDir (destStat, src, dest, opts, cb) { + const destParent = path.dirname(dest) + pathExists(destParent, (err, dirExists) => { + if (err) return cb(err) + if (dirExists) return startCopy(destStat, src, dest, opts, cb) + mkdirs(destParent, err => { + if (err) return cb(err) + return startCopy(destStat, src, dest, opts, cb) + }) + }) +} + +function handleFilter (onInclude, destStat, src, dest, opts, cb) { + Promise.resolve(opts.filter(src, dest)).then(include => { + if (include) return onInclude(destStat, src, dest, opts, cb) + return cb() + }, error => cb(error)) +} + +function startCopy (destStat, src, dest, opts, cb) { + if (opts.filter) return handleFilter(getStats, destStat, src, dest, opts, cb) + return getStats(destStat, src, dest, opts, cb) +} + +function getStats (destStat, src, dest, opts, cb) { + const stat = opts.dereference ? fs.stat : fs.lstat + stat(src, (err, srcStat) => { + if (err) return cb(err) + + if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts, cb) + else if (srcStat.isFile() || + srcStat.isCharacterDevice() || + srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts, cb) + else if (srcStat.isSymbolicLink()) return onLink(destStat, src, dest, opts, cb) + }) +} + +function onFile (srcStat, destStat, src, dest, opts, cb) { + if (!destStat) return copyFile(srcStat, src, dest, opts, cb) + return mayCopyFile(srcStat, src, dest, opts, cb) +} + +function mayCopyFile (srcStat, src, dest, opts, cb) { + if (opts.overwrite) { + fs.unlink(dest, err => { + if (err) return cb(err) + return copyFile(srcStat, src, dest, opts, cb) + }) + } else if (opts.errorOnExist) { + return cb(new Error(`'${dest}' already exists`)) + } else return cb() +} + +function copyFile (srcStat, src, dest, opts, cb) { + fs.copyFile(src, dest, err => { + if (err) return cb(err) + if (opts.preserveTimestamps) return handleTimestampsAndMode(srcStat.mode, src, dest, cb) + return setDestMode(dest, srcStat.mode, cb) + }) +} + +function handleTimestampsAndMode (srcMode, src, dest, cb) { + // Make sure the file is writable before setting the timestamp + // otherwise open fails with EPERM when invoked with 'r+' + // (through utimes call) + if (fileIsNotWritable(srcMode)) { + return makeFileWritable(dest, srcMode, err => { + if (err) return cb(err) + return setDestTimestampsAndMode(srcMode, src, dest, cb) + }) + } + return setDestTimestampsAndMode(srcMode, src, dest, cb) +} + +function fileIsNotWritable (srcMode) { + return (srcMode & 0o200) === 0 +} + +function makeFileWritable (dest, srcMode, cb) { + return setDestMode(dest, srcMode | 0o200, cb) +} + +function setDestTimestampsAndMode (srcMode, src, dest, cb) { + setDestTimestamps(src, dest, err => { + if (err) return cb(err) + return setDestMode(dest, srcMode, cb) + }) +} + +function setDestMode (dest, srcMode, cb) { + return fs.chmod(dest, srcMode, cb) +} + +function setDestTimestamps (src, dest, cb) { + // The initial srcStat.atime cannot be trusted + // because it is modified by the read(2) system call + // (See https://nodejs.org/api/fs.html#fs_stat_time_values) + fs.stat(src, (err, updatedSrcStat) => { + if (err) return cb(err) + return utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime, cb) + }) +} + +function onDir (srcStat, destStat, src, dest, opts, cb) { + if (!destStat) return mkDirAndCopy(srcStat.mode, src, dest, opts, cb) + if (destStat && !destStat.isDirectory()) { + return cb(new Error(`Cannot overwrite non-directory '${dest}' with directory '${src}'.`)) + } + return copyDir(src, dest, opts, cb) +} + +function mkDirAndCopy (srcMode, src, dest, opts, cb) { + fs.mkdir(dest, err => { + if (err) return cb(err) + copyDir(src, dest, opts, err => { + if (err) return cb(err) + return setDestMode(dest, srcMode, cb) + }) + }) +} + +function copyDir (src, dest, opts, cb) { + fs.readdir(src, (err, items) => { + if (err) return cb(err) + return copyDirItems(items, src, dest, opts, cb) + }) +} + +function copyDirItems (items, src, dest, opts, cb) { + const item = items.pop() + if (!item) return cb() + return copyDirItem(items, item, src, dest, opts, cb) +} + +function copyDirItem (items, item, src, dest, opts, cb) { + const srcItem = path.join(src, item) + const destItem = path.join(dest, item) + stat.checkPaths(srcItem, destItem, 'copy', (err, stats) => { + if (err) return cb(err) + const { destStat } = stats + startCopy(destStat, srcItem, destItem, opts, err => { + if (err) return cb(err) + return copyDirItems(items, src, dest, opts, cb) + }) + }) +} + +function onLink (destStat, src, dest, opts, cb) { + fs.readlink(src, (err, resolvedSrc) => { + if (err) return cb(err) + if (opts.dereference) { + resolvedSrc = path.resolve(process.cwd(), resolvedSrc) + } + + if (!destStat) { + return fs.symlink(resolvedSrc, dest, cb) + } else { + fs.readlink(dest, (err, resolvedDest) => { + if (err) { + // dest exists and is a regular file or directory, + // Windows may throw UNKNOWN error. If dest already exists, + // fs throws error anyway, so no need to guard against it here. + if (err.code === 'EINVAL' || err.code === 'UNKNOWN') return fs.symlink(resolvedSrc, dest, cb) + return cb(err) + } + if (opts.dereference) { + resolvedDest = path.resolve(process.cwd(), resolvedDest) + } + if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) { + return cb(new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`)) + } + + // do not copy if src is a subdir of dest since unlinking + // dest in this case would result in removing src contents + // and therefore a broken symlink would be created. + if (destStat.isDirectory() && stat.isSrcSubdir(resolvedDest, resolvedSrc)) { + return cb(new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`)) + } + return copyLink(resolvedSrc, dest, cb) + }) + } + }) +} + +function copyLink (resolvedSrc, dest, cb) { + fs.unlink(dest, err => { + if (err) return cb(err) + return fs.symlink(resolvedSrc, dest, cb) + }) +} + +module.exports = copy diff --git a/tools/ui/node_modules/fs-extra/lib/copy/index.js b/tools/ui/node_modules/fs-extra/lib/copy/index.js new file mode 100644 index 0000000000000000000000000000000000000000..b7e4f7f8d4d5d819b39e73e7ebe85f7b90683c46 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/copy/index.js @@ -0,0 +1,6 @@ +'use strict' + +const u = require('universalify').fromCallback +module.exports = { + copy: u(require('./copy')) +} diff --git a/tools/ui/node_modules/fs-extra/lib/empty/index.js b/tools/ui/node_modules/fs-extra/lib/empty/index.js new file mode 100644 index 0000000000000000000000000000000000000000..90fb46991e8fded0a31ccee5f3ce5d36f1f7476a --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/empty/index.js @@ -0,0 +1,48 @@ +'use strict' + +const u = require('universalify').fromCallback +const fs = require('graceful-fs') +const path = require('path') +const mkdir = require('../mkdirs') +const remove = require('../remove') + +const emptyDir = u(function emptyDir (dir, callback) { + callback = callback || function () {} + fs.readdir(dir, (err, items) => { + if (err) return mkdir.mkdirs(dir, callback) + + items = items.map(item => path.join(dir, item)) + + deleteItem() + + function deleteItem () { + const item = items.pop() + if (!item) return callback() + remove.remove(item, err => { + if (err) return callback(err) + deleteItem() + }) + } + }) +}) + +function emptyDirSync (dir) { + let items + try { + items = fs.readdirSync(dir) + } catch { + return mkdir.mkdirsSync(dir) + } + + items.forEach(item => { + item = path.join(dir, item) + remove.removeSync(item) + }) +} + +module.exports = { + emptyDirSync, + emptydirSync: emptyDirSync, + emptyDir, + emptydir: emptyDir +} diff --git a/tools/ui/node_modules/fs-extra/lib/ensure/file.js b/tools/ui/node_modules/fs-extra/lib/ensure/file.js new file mode 100644 index 0000000000000000000000000000000000000000..15cc473c8a74fbe6e832712cf6015fd06f830415 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/ensure/file.js @@ -0,0 +1,69 @@ +'use strict' + +const u = require('universalify').fromCallback +const path = require('path') +const fs = require('graceful-fs') +const mkdir = require('../mkdirs') + +function createFile (file, callback) { + function makeFile () { + fs.writeFile(file, '', err => { + if (err) return callback(err) + callback() + }) + } + + fs.stat(file, (err, stats) => { // eslint-disable-line handle-callback-err + if (!err && stats.isFile()) return callback() + const dir = path.dirname(file) + fs.stat(dir, (err, stats) => { + if (err) { + // if the directory doesn't exist, make it + if (err.code === 'ENOENT') { + return mkdir.mkdirs(dir, err => { + if (err) return callback(err) + makeFile() + }) + } + return callback(err) + } + + if (stats.isDirectory()) makeFile() + else { + // parent is not a directory + // This is just to cause an internal ENOTDIR error to be thrown + fs.readdir(dir, err => { + if (err) return callback(err) + }) + } + }) + }) +} + +function createFileSync (file) { + let stats + try { + stats = fs.statSync(file) + } catch {} + if (stats && stats.isFile()) return + + const dir = path.dirname(file) + try { + if (!fs.statSync(dir).isDirectory()) { + // parent is not a directory + // This is just to cause an internal ENOTDIR error to be thrown + fs.readdirSync(dir) + } + } catch (err) { + // If the stat call above failed because the directory doesn't exist, create it + if (err && err.code === 'ENOENT') mkdir.mkdirsSync(dir) + else throw err + } + + fs.writeFileSync(file, '') +} + +module.exports = { + createFile: u(createFile), + createFileSync +} diff --git a/tools/ui/node_modules/fs-extra/lib/ensure/index.js b/tools/ui/node_modules/fs-extra/lib/ensure/index.js new file mode 100644 index 0000000000000000000000000000000000000000..c1f67b71878b3db1a5d82c9a1ac0655d5558c03e --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/ensure/index.js @@ -0,0 +1,23 @@ +'use strict' + +const file = require('./file') +const link = require('./link') +const symlink = require('./symlink') + +module.exports = { + // file + createFile: file.createFile, + createFileSync: file.createFileSync, + ensureFile: file.createFile, + ensureFileSync: file.createFileSync, + // link + createLink: link.createLink, + createLinkSync: link.createLinkSync, + ensureLink: link.createLink, + ensureLinkSync: link.createLinkSync, + // symlink + createSymlink: symlink.createSymlink, + createSymlinkSync: symlink.createSymlinkSync, + ensureSymlink: symlink.createSymlink, + ensureSymlinkSync: symlink.createSymlinkSync +} diff --git a/tools/ui/node_modules/fs-extra/lib/ensure/link.js b/tools/ui/node_modules/fs-extra/lib/ensure/link.js new file mode 100644 index 0000000000000000000000000000000000000000..2cd419626a6658ce2403689d541d11ab4d8aafe8 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/ensure/link.js @@ -0,0 +1,61 @@ +'use strict' + +const u = require('universalify').fromCallback +const path = require('path') +const fs = require('graceful-fs') +const mkdir = require('../mkdirs') +const pathExists = require('../path-exists').pathExists + +function createLink (srcpath, dstpath, callback) { + function makeLink (srcpath, dstpath) { + fs.link(srcpath, dstpath, err => { + if (err) return callback(err) + callback(null) + }) + } + + pathExists(dstpath, (err, destinationExists) => { + if (err) return callback(err) + if (destinationExists) return callback(null) + fs.lstat(srcpath, (err) => { + if (err) { + err.message = err.message.replace('lstat', 'ensureLink') + return callback(err) + } + + const dir = path.dirname(dstpath) + pathExists(dir, (err, dirExists) => { + if (err) return callback(err) + if (dirExists) return makeLink(srcpath, dstpath) + mkdir.mkdirs(dir, err => { + if (err) return callback(err) + makeLink(srcpath, dstpath) + }) + }) + }) + }) +} + +function createLinkSync (srcpath, dstpath) { + const destinationExists = fs.existsSync(dstpath) + if (destinationExists) return undefined + + try { + fs.lstatSync(srcpath) + } catch (err) { + err.message = err.message.replace('lstat', 'ensureLink') + throw err + } + + const dir = path.dirname(dstpath) + const dirExists = fs.existsSync(dir) + if (dirExists) return fs.linkSync(srcpath, dstpath) + mkdir.mkdirsSync(dir) + + return fs.linkSync(srcpath, dstpath) +} + +module.exports = { + createLink: u(createLink), + createLinkSync +} diff --git a/tools/ui/node_modules/fs-extra/lib/ensure/symlink-paths.js b/tools/ui/node_modules/fs-extra/lib/ensure/symlink-paths.js new file mode 100644 index 0000000000000000000000000000000000000000..33cd76000e6bdcdbb0a87d096100c5771316b119 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/ensure/symlink-paths.js @@ -0,0 +1,99 @@ +'use strict' + +const path = require('path') +const fs = require('graceful-fs') +const pathExists = require('../path-exists').pathExists + +/** + * Function that returns two types of paths, one relative to symlink, and one + * relative to the current working directory. Checks if path is absolute or + * relative. If the path is relative, this function checks if the path is + * relative to symlink or relative to current working directory. This is an + * initiative to find a smarter `srcpath` to supply when building symlinks. + * This allows you to determine which path to use out of one of three possible + * types of source paths. The first is an absolute path. This is detected by + * `path.isAbsolute()`. When an absolute path is provided, it is checked to + * see if it exists. If it does it's used, if not an error is returned + * (callback)/ thrown (sync). The other two options for `srcpath` are a + * relative url. By default Node's `fs.symlink` works by creating a symlink + * using `dstpath` and expects the `srcpath` to be relative to the newly + * created symlink. If you provide a `srcpath` that does not exist on the file + * system it results in a broken symlink. To minimize this, the function + * checks to see if the 'relative to symlink' source file exists, and if it + * does it will use it. If it does not, it checks if there's a file that + * exists that is relative to the current working directory, if does its used. + * This preserves the expectations of the original fs.symlink spec and adds + * the ability to pass in `relative to current working direcotry` paths. + */ + +function symlinkPaths (srcpath, dstpath, callback) { + if (path.isAbsolute(srcpath)) { + return fs.lstat(srcpath, (err) => { + if (err) { + err.message = err.message.replace('lstat', 'ensureSymlink') + return callback(err) + } + return callback(null, { + toCwd: srcpath, + toDst: srcpath + }) + }) + } else { + const dstdir = path.dirname(dstpath) + const relativeToDst = path.join(dstdir, srcpath) + return pathExists(relativeToDst, (err, exists) => { + if (err) return callback(err) + if (exists) { + return callback(null, { + toCwd: relativeToDst, + toDst: srcpath + }) + } else { + return fs.lstat(srcpath, (err) => { + if (err) { + err.message = err.message.replace('lstat', 'ensureSymlink') + return callback(err) + } + return callback(null, { + toCwd: srcpath, + toDst: path.relative(dstdir, srcpath) + }) + }) + } + }) + } +} + +function symlinkPathsSync (srcpath, dstpath) { + let exists + if (path.isAbsolute(srcpath)) { + exists = fs.existsSync(srcpath) + if (!exists) throw new Error('absolute srcpath does not exist') + return { + toCwd: srcpath, + toDst: srcpath + } + } else { + const dstdir = path.dirname(dstpath) + const relativeToDst = path.join(dstdir, srcpath) + exists = fs.existsSync(relativeToDst) + if (exists) { + return { + toCwd: relativeToDst, + toDst: srcpath + } + } else { + exists = fs.existsSync(srcpath) + if (!exists) throw new Error('relative srcpath does not exist') + return { + toCwd: srcpath, + toDst: path.relative(dstdir, srcpath) + } + } + } +} + +module.exports = { + symlinkPaths, + symlinkPathsSync +} diff --git a/tools/ui/node_modules/fs-extra/lib/ensure/symlink-type.js b/tools/ui/node_modules/fs-extra/lib/ensure/symlink-type.js new file mode 100644 index 0000000000000000000000000000000000000000..42dc0ce753d641a72c453fb1a3cd09cbb1196e97 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/ensure/symlink-type.js @@ -0,0 +1,31 @@ +'use strict' + +const fs = require('graceful-fs') + +function symlinkType (srcpath, type, callback) { + callback = (typeof type === 'function') ? type : callback + type = (typeof type === 'function') ? false : type + if (type) return callback(null, type) + fs.lstat(srcpath, (err, stats) => { + if (err) return callback(null, 'file') + type = (stats && stats.isDirectory()) ? 'dir' : 'file' + callback(null, type) + }) +} + +function symlinkTypeSync (srcpath, type) { + let stats + + if (type) return type + try { + stats = fs.lstatSync(srcpath) + } catch { + return 'file' + } + return (stats && stats.isDirectory()) ? 'dir' : 'file' +} + +module.exports = { + symlinkType, + symlinkTypeSync +} diff --git a/tools/ui/node_modules/fs-extra/lib/ensure/symlink.js b/tools/ui/node_modules/fs-extra/lib/ensure/symlink.js new file mode 100644 index 0000000000000000000000000000000000000000..fe68b799787243921c6acd712d438c708a392e02 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/ensure/symlink.js @@ -0,0 +1,63 @@ +'use strict' + +const u = require('universalify').fromCallback +const path = require('path') +const fs = require('graceful-fs') +const _mkdirs = require('../mkdirs') +const mkdirs = _mkdirs.mkdirs +const mkdirsSync = _mkdirs.mkdirsSync + +const _symlinkPaths = require('./symlink-paths') +const symlinkPaths = _symlinkPaths.symlinkPaths +const symlinkPathsSync = _symlinkPaths.symlinkPathsSync + +const _symlinkType = require('./symlink-type') +const symlinkType = _symlinkType.symlinkType +const symlinkTypeSync = _symlinkType.symlinkTypeSync + +const pathExists = require('../path-exists').pathExists + +function createSymlink (srcpath, dstpath, type, callback) { + callback = (typeof type === 'function') ? type : callback + type = (typeof type === 'function') ? false : type + + pathExists(dstpath, (err, destinationExists) => { + if (err) return callback(err) + if (destinationExists) return callback(null) + symlinkPaths(srcpath, dstpath, (err, relative) => { + if (err) return callback(err) + srcpath = relative.toDst + symlinkType(relative.toCwd, type, (err, type) => { + if (err) return callback(err) + const dir = path.dirname(dstpath) + pathExists(dir, (err, dirExists) => { + if (err) return callback(err) + if (dirExists) return fs.symlink(srcpath, dstpath, type, callback) + mkdirs(dir, err => { + if (err) return callback(err) + fs.symlink(srcpath, dstpath, type, callback) + }) + }) + }) + }) + }) +} + +function createSymlinkSync (srcpath, dstpath, type) { + const destinationExists = fs.existsSync(dstpath) + if (destinationExists) return undefined + + const relative = symlinkPathsSync(srcpath, dstpath) + srcpath = relative.toDst + type = symlinkTypeSync(relative.toCwd, type) + const dir = path.dirname(dstpath) + const exists = fs.existsSync(dir) + if (exists) return fs.symlinkSync(srcpath, dstpath, type) + mkdirsSync(dir) + return fs.symlinkSync(srcpath, dstpath, type) +} + +module.exports = { + createSymlink: u(createSymlink), + createSymlinkSync +} diff --git a/tools/ui/node_modules/fs-extra/lib/fs/index.js b/tools/ui/node_modules/fs-extra/lib/fs/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9bbaea4e40173061c923fe426e64d331f67be16b --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/fs/index.js @@ -0,0 +1,130 @@ +'use strict' +// This is adapted from https://github.com/normalize/mz +// Copyright (c) 2014-2016 Jonathan Ong me@jongleberry.com and Contributors +const u = require('universalify').fromCallback +const fs = require('graceful-fs') + +const api = [ + 'access', + 'appendFile', + 'chmod', + 'chown', + 'close', + 'copyFile', + 'fchmod', + 'fchown', + 'fdatasync', + 'fstat', + 'fsync', + 'ftruncate', + 'futimes', + 'lchmod', + 'lchown', + 'link', + 'lstat', + 'mkdir', + 'mkdtemp', + 'open', + 'opendir', + 'readdir', + 'readFile', + 'readlink', + 'realpath', + 'rename', + 'rm', + 'rmdir', + 'stat', + 'symlink', + 'truncate', + 'unlink', + 'utimes', + 'writeFile' +].filter(key => { + // Some commands are not available on some systems. Ex: + // fs.opendir was added in Node.js v12.12.0 + // fs.rm was added in Node.js v14.14.0 + // fs.lchown is not available on at least some Linux + return typeof fs[key] === 'function' +}) + +// Export all keys: +Object.keys(fs).forEach(key => { + if (key === 'promises') { + // fs.promises is a getter property that triggers ExperimentalWarning + // Don't re-export it here, the getter is defined in "lib/index.js" + return + } + exports[key] = fs[key] +}) + +// Universalify async methods: +api.forEach(method => { + exports[method] = u(fs[method]) +}) + +// We differ from mz/fs in that we still ship the old, broken, fs.exists() +// since we are a drop-in replacement for the native module +exports.exists = function (filename, callback) { + if (typeof callback === 'function') { + return fs.exists(filename, callback) + } + return new Promise(resolve => { + return fs.exists(filename, resolve) + }) +} + +// fs.read(), fs.write(), & fs.writev() need special treatment due to multiple callback args + +exports.read = function (fd, buffer, offset, length, position, callback) { + if (typeof callback === 'function') { + return fs.read(fd, buffer, offset, length, position, callback) + } + return new Promise((resolve, reject) => { + fs.read(fd, buffer, offset, length, position, (err, bytesRead, buffer) => { + if (err) return reject(err) + resolve({ bytesRead, buffer }) + }) + }) +} + +// Function signature can be +// fs.write(fd, buffer[, offset[, length[, position]]], callback) +// OR +// fs.write(fd, string[, position[, encoding]], callback) +// We need to handle both cases, so we use ...args +exports.write = function (fd, buffer, ...args) { + if (typeof args[args.length - 1] === 'function') { + return fs.write(fd, buffer, ...args) + } + + return new Promise((resolve, reject) => { + fs.write(fd, buffer, ...args, (err, bytesWritten, buffer) => { + if (err) return reject(err) + resolve({ bytesWritten, buffer }) + }) + }) +} + +// fs.writev only available in Node v12.9.0+ +if (typeof fs.writev === 'function') { + // Function signature is + // s.writev(fd, buffers[, position], callback) + // We need to handle the optional arg, so we use ...args + exports.writev = function (fd, buffers, ...args) { + if (typeof args[args.length - 1] === 'function') { + return fs.writev(fd, buffers, ...args) + } + + return new Promise((resolve, reject) => { + fs.writev(fd, buffers, ...args, (err, bytesWritten, buffers) => { + if (err) return reject(err) + resolve({ bytesWritten, buffers }) + }) + }) + } +} + +// fs.realpath.native only available in Node v9.2+ +if (typeof fs.realpath.native === 'function') { + exports.realpath.native = u(fs.realpath.native) +} diff --git a/tools/ui/node_modules/fs-extra/lib/index.js b/tools/ui/node_modules/fs-extra/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..d9468e699c118aa316bb2bca78a95ef2ed4e44a8 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/index.js @@ -0,0 +1,27 @@ +'use strict' + +module.exports = { + // Export promiseified graceful-fs: + ...require('./fs'), + // Export extra methods: + ...require('./copy-sync'), + ...require('./copy'), + ...require('./empty'), + ...require('./ensure'), + ...require('./json'), + ...require('./mkdirs'), + ...require('./move-sync'), + ...require('./move'), + ...require('./output'), + ...require('./path-exists'), + ...require('./remove') +} + +// Export fs.promises as a getter property so that we don't trigger +// ExperimentalWarning before fs.promises is actually accessed. +const fs = require('fs') +if (Object.getOwnPropertyDescriptor(fs, 'promises')) { + Object.defineProperty(module.exports, 'promises', { + get () { return fs.promises } + }) +} diff --git a/tools/ui/node_modules/fs-extra/lib/json/index.js b/tools/ui/node_modules/fs-extra/lib/json/index.js new file mode 100644 index 0000000000000000000000000000000000000000..900126ad0bf741e2f7fb426c9ea95d1124fe09bb --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/json/index.js @@ -0,0 +1,16 @@ +'use strict' + +const u = require('universalify').fromPromise +const jsonFile = require('./jsonfile') + +jsonFile.outputJson = u(require('./output-json')) +jsonFile.outputJsonSync = require('./output-json-sync') +// aliases +jsonFile.outputJSON = jsonFile.outputJson +jsonFile.outputJSONSync = jsonFile.outputJsonSync +jsonFile.writeJSON = jsonFile.writeJson +jsonFile.writeJSONSync = jsonFile.writeJsonSync +jsonFile.readJSON = jsonFile.readJson +jsonFile.readJSONSync = jsonFile.readJsonSync + +module.exports = jsonFile diff --git a/tools/ui/node_modules/fs-extra/lib/json/jsonfile.js b/tools/ui/node_modules/fs-extra/lib/json/jsonfile.js new file mode 100644 index 0000000000000000000000000000000000000000..f11d34d623d879f1d443dfa8e4e2ce4e13170b75 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/json/jsonfile.js @@ -0,0 +1,11 @@ +'use strict' + +const jsonFile = require('jsonfile') + +module.exports = { + // jsonfile exports + readJson: jsonFile.readFile, + readJsonSync: jsonFile.readFileSync, + writeJson: jsonFile.writeFile, + writeJsonSync: jsonFile.writeFileSync +} diff --git a/tools/ui/node_modules/fs-extra/lib/json/output-json-sync.js b/tools/ui/node_modules/fs-extra/lib/json/output-json-sync.js new file mode 100644 index 0000000000000000000000000000000000000000..f76b4744ce5e2dd57653a0228b07a8bbbad44367 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/json/output-json-sync.js @@ -0,0 +1,12 @@ +'use strict' + +const { stringify } = require('jsonfile/utils') +const { outputFileSync } = require('../output') + +function outputJsonSync (file, data, options) { + const str = stringify(data, options) + + outputFileSync(file, str, options) +} + +module.exports = outputJsonSync diff --git a/tools/ui/node_modules/fs-extra/lib/json/output-json.js b/tools/ui/node_modules/fs-extra/lib/json/output-json.js new file mode 100644 index 0000000000000000000000000000000000000000..0fc668977fca888760aded57498aa2733509bc2f --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/json/output-json.js @@ -0,0 +1,12 @@ +'use strict' + +const { stringify } = require('jsonfile/utils') +const { outputFile } = require('../output') + +async function outputJson (file, data, options = {}) { + const str = stringify(data, options) + + await outputFile(file, str, options) +} + +module.exports = outputJson diff --git a/tools/ui/node_modules/fs-extra/lib/mkdirs/index.js b/tools/ui/node_modules/fs-extra/lib/mkdirs/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9edecee08f1f86a9b5541927823469788949e6d1 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/mkdirs/index.js @@ -0,0 +1,14 @@ +'use strict' +const u = require('universalify').fromPromise +const { makeDir: _makeDir, makeDirSync } = require('./make-dir') +const makeDir = u(_makeDir) + +module.exports = { + mkdirs: makeDir, + mkdirsSync: makeDirSync, + // alias + mkdirp: makeDir, + mkdirpSync: makeDirSync, + ensureDir: makeDir, + ensureDirSync: makeDirSync +} diff --git a/tools/ui/node_modules/fs-extra/lib/mkdirs/make-dir.js b/tools/ui/node_modules/fs-extra/lib/mkdirs/make-dir.js new file mode 100644 index 0000000000000000000000000000000000000000..3e7e8360549ff526fd4f4359d0f9063de0e5f3b1 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/mkdirs/make-dir.js @@ -0,0 +1,141 @@ +// Adapted from https://github.com/sindresorhus/make-dir +// Copyright (c) Sindre Sorhus (sindresorhus.com) +// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: +// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +'use strict' +const fs = require('../fs') +const path = require('path') +const atLeastNode = require('at-least-node') + +const useNativeRecursiveOption = atLeastNode('10.12.0') + +// https://github.com/nodejs/node/issues/8987 +// https://github.com/libuv/libuv/pull/1088 +const checkPath = pth => { + if (process.platform === 'win32') { + const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path.parse(pth).root, '')) + + if (pathHasInvalidWinCharacters) { + const error = new Error(`Path contains invalid characters: ${pth}`) + error.code = 'EINVAL' + throw error + } + } +} + +const processOptions = options => { + const defaults = { mode: 0o777 } + if (typeof options === 'number') options = { mode: options } + return { ...defaults, ...options } +} + +const permissionError = pth => { + // This replicates the exception of `fs.mkdir` with native the + // `recusive` option when run on an invalid drive under Windows. + const error = new Error(`operation not permitted, mkdir '${pth}'`) + error.code = 'EPERM' + error.errno = -4048 + error.path = pth + error.syscall = 'mkdir' + return error +} + +module.exports.makeDir = async (input, options) => { + checkPath(input) + options = processOptions(options) + + if (useNativeRecursiveOption) { + const pth = path.resolve(input) + + return fs.mkdir(pth, { + mode: options.mode, + recursive: true + }) + } + + const make = async pth => { + try { + await fs.mkdir(pth, options.mode) + } catch (error) { + if (error.code === 'EPERM') { + throw error + } + + if (error.code === 'ENOENT') { + if (path.dirname(pth) === pth) { + throw permissionError(pth) + } + + if (error.message.includes('null bytes')) { + throw error + } + + await make(path.dirname(pth)) + return make(pth) + } + + try { + const stats = await fs.stat(pth) + if (!stats.isDirectory()) { + // This error is never exposed to the user + // it is caught below, and the original error is thrown + throw new Error('The path is not a directory') + } + } catch { + throw error + } + } + } + + return make(path.resolve(input)) +} + +module.exports.makeDirSync = (input, options) => { + checkPath(input) + options = processOptions(options) + + if (useNativeRecursiveOption) { + const pth = path.resolve(input) + + return fs.mkdirSync(pth, { + mode: options.mode, + recursive: true + }) + } + + const make = pth => { + try { + fs.mkdirSync(pth, options.mode) + } catch (error) { + if (error.code === 'EPERM') { + throw error + } + + if (error.code === 'ENOENT') { + if (path.dirname(pth) === pth) { + throw permissionError(pth) + } + + if (error.message.includes('null bytes')) { + throw error + } + + make(path.dirname(pth)) + return make(pth) + } + + try { + if (!fs.statSync(pth).isDirectory()) { + // This error is never exposed to the user + // it is caught below, and the original error is thrown + throw new Error('The path is not a directory') + } + } catch { + throw error + } + } + } + + return make(path.resolve(input)) +} diff --git a/tools/ui/node_modules/fs-extra/lib/move-sync/index.js b/tools/ui/node_modules/fs-extra/lib/move-sync/index.js new file mode 100644 index 0000000000000000000000000000000000000000..af90b06b423b9d3af43a81e090a784700bef9e3e --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/move-sync/index.js @@ -0,0 +1,5 @@ +'use strict' + +module.exports = { + moveSync: require('./move-sync') +} diff --git a/tools/ui/node_modules/fs-extra/lib/move-sync/move-sync.js b/tools/ui/node_modules/fs-extra/lib/move-sync/move-sync.js new file mode 100644 index 0000000000000000000000000000000000000000..20f910cc258f8f2969a66d538e2d1703c4de98af --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/move-sync/move-sync.js @@ -0,0 +1,47 @@ +'use strict' + +const fs = require('graceful-fs') +const path = require('path') +const copySync = require('../copy-sync').copySync +const removeSync = require('../remove').removeSync +const mkdirpSync = require('../mkdirs').mkdirpSync +const stat = require('../util/stat') + +function moveSync (src, dest, opts) { + opts = opts || {} + const overwrite = opts.overwrite || opts.clobber || false + + const { srcStat } = stat.checkPathsSync(src, dest, 'move') + stat.checkParentPathsSync(src, srcStat, dest, 'move') + mkdirpSync(path.dirname(dest)) + return doRename(src, dest, overwrite) +} + +function doRename (src, dest, overwrite) { + if (overwrite) { + removeSync(dest) + return rename(src, dest, overwrite) + } + if (fs.existsSync(dest)) throw new Error('dest already exists.') + return rename(src, dest, overwrite) +} + +function rename (src, dest, overwrite) { + try { + fs.renameSync(src, dest) + } catch (err) { + if (err.code !== 'EXDEV') throw err + return moveAcrossDevice(src, dest, overwrite) + } +} + +function moveAcrossDevice (src, dest, overwrite) { + const opts = { + overwrite, + errorOnExist: true + } + copySync(src, dest, opts) + return removeSync(src) +} + +module.exports = moveSync diff --git a/tools/ui/node_modules/fs-extra/lib/move/index.js b/tools/ui/node_modules/fs-extra/lib/move/index.js new file mode 100644 index 0000000000000000000000000000000000000000..3785345bd2670db9bdf41e3c4766d1b5d5a34813 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/move/index.js @@ -0,0 +1,6 @@ +'use strict' + +const u = require('universalify').fromCallback +module.exports = { + move: u(require('./move')) +} diff --git a/tools/ui/node_modules/fs-extra/lib/move/move.js b/tools/ui/node_modules/fs-extra/lib/move/move.js new file mode 100644 index 0000000000000000000000000000000000000000..fa3ea618a29b6de8b76f4318c0b99700f878b39a --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/move/move.js @@ -0,0 +1,65 @@ +'use strict' + +const fs = require('graceful-fs') +const path = require('path') +const copy = require('../copy').copy +const remove = require('../remove').remove +const mkdirp = require('../mkdirs').mkdirp +const pathExists = require('../path-exists').pathExists +const stat = require('../util/stat') + +function move (src, dest, opts, cb) { + if (typeof opts === 'function') { + cb = opts + opts = {} + } + + const overwrite = opts.overwrite || opts.clobber || false + + stat.checkPaths(src, dest, 'move', (err, stats) => { + if (err) return cb(err) + const { srcStat } = stats + stat.checkParentPaths(src, srcStat, dest, 'move', err => { + if (err) return cb(err) + mkdirp(path.dirname(dest), err => { + if (err) return cb(err) + return doRename(src, dest, overwrite, cb) + }) + }) + }) +} + +function doRename (src, dest, overwrite, cb) { + if (overwrite) { + return remove(dest, err => { + if (err) return cb(err) + return rename(src, dest, overwrite, cb) + }) + } + pathExists(dest, (err, destExists) => { + if (err) return cb(err) + if (destExists) return cb(new Error('dest already exists.')) + return rename(src, dest, overwrite, cb) + }) +} + +function rename (src, dest, overwrite, cb) { + fs.rename(src, dest, err => { + if (!err) return cb() + if (err.code !== 'EXDEV') return cb(err) + return moveAcrossDevice(src, dest, overwrite, cb) + }) +} + +function moveAcrossDevice (src, dest, overwrite, cb) { + const opts = { + overwrite, + errorOnExist: true + } + copy(src, dest, opts, err => { + if (err) return cb(err) + return remove(src, cb) + }) +} + +module.exports = move diff --git a/tools/ui/node_modules/fs-extra/lib/output/index.js b/tools/ui/node_modules/fs-extra/lib/output/index.js new file mode 100644 index 0000000000000000000000000000000000000000..92297ca3a68cc16713fb25504d3800bad744fb72 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/output/index.js @@ -0,0 +1,40 @@ +'use strict' + +const u = require('universalify').fromCallback +const fs = require('graceful-fs') +const path = require('path') +const mkdir = require('../mkdirs') +const pathExists = require('../path-exists').pathExists + +function outputFile (file, data, encoding, callback) { + if (typeof encoding === 'function') { + callback = encoding + encoding = 'utf8' + } + + const dir = path.dirname(file) + pathExists(dir, (err, itDoes) => { + if (err) return callback(err) + if (itDoes) return fs.writeFile(file, data, encoding, callback) + + mkdir.mkdirs(dir, err => { + if (err) return callback(err) + + fs.writeFile(file, data, encoding, callback) + }) + }) +} + +function outputFileSync (file, ...args) { + const dir = path.dirname(file) + if (fs.existsSync(dir)) { + return fs.writeFileSync(file, ...args) + } + mkdir.mkdirsSync(dir) + fs.writeFileSync(file, ...args) +} + +module.exports = { + outputFile: u(outputFile), + outputFileSync +} diff --git a/tools/ui/node_modules/fs-extra/lib/path-exists/index.js b/tools/ui/node_modules/fs-extra/lib/path-exists/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ddd9bc718f73367de57c345c3bfcd236c579dc2f --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/path-exists/index.js @@ -0,0 +1,12 @@ +'use strict' +const u = require('universalify').fromPromise +const fs = require('../fs') + +function pathExists (path) { + return fs.access(path).then(() => true).catch(() => false) +} + +module.exports = { + pathExists: u(pathExists), + pathExistsSync: fs.existsSync +} diff --git a/tools/ui/node_modules/fs-extra/lib/remove/index.js b/tools/ui/node_modules/fs-extra/lib/remove/index.js new file mode 100644 index 0000000000000000000000000000000000000000..cee53400775592ea7f5e6fc3f9d450a62772fbdb --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/remove/index.js @@ -0,0 +1,9 @@ +'use strict' + +const u = require('universalify').fromCallback +const rimraf = require('./rimraf') + +module.exports = { + remove: u(rimraf), + removeSync: rimraf.sync +} diff --git a/tools/ui/node_modules/fs-extra/lib/remove/rimraf.js b/tools/ui/node_modules/fs-extra/lib/remove/rimraf.js new file mode 100644 index 0000000000000000000000000000000000000000..2c771026586fd6ef15ed120d105df2a804779453 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/remove/rimraf.js @@ -0,0 +1,302 @@ +'use strict' + +const fs = require('graceful-fs') +const path = require('path') +const assert = require('assert') + +const isWindows = (process.platform === 'win32') + +function defaults (options) { + const methods = [ + 'unlink', + 'chmod', + 'stat', + 'lstat', + 'rmdir', + 'readdir' + ] + methods.forEach(m => { + options[m] = options[m] || fs[m] + m = m + 'Sync' + options[m] = options[m] || fs[m] + }) + + options.maxBusyTries = options.maxBusyTries || 3 +} + +function rimraf (p, options, cb) { + let busyTries = 0 + + if (typeof options === 'function') { + cb = options + options = {} + } + + assert(p, 'rimraf: missing path') + assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string') + assert.strictEqual(typeof cb, 'function', 'rimraf: callback function required') + assert(options, 'rimraf: invalid options argument provided') + assert.strictEqual(typeof options, 'object', 'rimraf: options should be object') + + defaults(options) + + rimraf_(p, options, function CB (er) { + if (er) { + if ((er.code === 'EBUSY' || er.code === 'ENOTEMPTY' || er.code === 'EPERM') && + busyTries < options.maxBusyTries) { + busyTries++ + const time = busyTries * 100 + // try again, with the same exact callback as this one. + return setTimeout(() => rimraf_(p, options, CB), time) + } + + // already gone + if (er.code === 'ENOENT') er = null + } + + cb(er) + }) +} + +// Two possible strategies. +// 1. Assume it's a file. unlink it, then do the dir stuff on EPERM or EISDIR +// 2. Assume it's a directory. readdir, then do the file stuff on ENOTDIR +// +// Both result in an extra syscall when you guess wrong. However, there +// are likely far more normal files in the world than directories. This +// is based on the assumption that a the average number of files per +// directory is >= 1. +// +// If anyone ever complains about this, then I guess the strategy could +// be made configurable somehow. But until then, YAGNI. +function rimraf_ (p, options, cb) { + assert(p) + assert(options) + assert(typeof cb === 'function') + + // sunos lets the root user unlink directories, which is... weird. + // so we have to lstat here and make sure it's not a dir. + options.lstat(p, (er, st) => { + if (er && er.code === 'ENOENT') { + return cb(null) + } + + // Windows can EPERM on stat. Life is suffering. + if (er && er.code === 'EPERM' && isWindows) { + return fixWinEPERM(p, options, er, cb) + } + + if (st && st.isDirectory()) { + return rmdir(p, options, er, cb) + } + + options.unlink(p, er => { + if (er) { + if (er.code === 'ENOENT') { + return cb(null) + } + if (er.code === 'EPERM') { + return (isWindows) + ? fixWinEPERM(p, options, er, cb) + : rmdir(p, options, er, cb) + } + if (er.code === 'EISDIR') { + return rmdir(p, options, er, cb) + } + } + return cb(er) + }) + }) +} + +function fixWinEPERM (p, options, er, cb) { + assert(p) + assert(options) + assert(typeof cb === 'function') + + options.chmod(p, 0o666, er2 => { + if (er2) { + cb(er2.code === 'ENOENT' ? null : er) + } else { + options.stat(p, (er3, stats) => { + if (er3) { + cb(er3.code === 'ENOENT' ? null : er) + } else if (stats.isDirectory()) { + rmdir(p, options, er, cb) + } else { + options.unlink(p, cb) + } + }) + } + }) +} + +function fixWinEPERMSync (p, options, er) { + let stats + + assert(p) + assert(options) + + try { + options.chmodSync(p, 0o666) + } catch (er2) { + if (er2.code === 'ENOENT') { + return + } else { + throw er + } + } + + try { + stats = options.statSync(p) + } catch (er3) { + if (er3.code === 'ENOENT') { + return + } else { + throw er + } + } + + if (stats.isDirectory()) { + rmdirSync(p, options, er) + } else { + options.unlinkSync(p) + } +} + +function rmdir (p, options, originalEr, cb) { + assert(p) + assert(options) + assert(typeof cb === 'function') + + // try to rmdir first, and only readdir on ENOTEMPTY or EEXIST (SunOS) + // if we guessed wrong, and it's not a directory, then + // raise the original error. + options.rmdir(p, er => { + if (er && (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM')) { + rmkids(p, options, cb) + } else if (er && er.code === 'ENOTDIR') { + cb(originalEr) + } else { + cb(er) + } + }) +} + +function rmkids (p, options, cb) { + assert(p) + assert(options) + assert(typeof cb === 'function') + + options.readdir(p, (er, files) => { + if (er) return cb(er) + + let n = files.length + let errState + + if (n === 0) return options.rmdir(p, cb) + + files.forEach(f => { + rimraf(path.join(p, f), options, er => { + if (errState) { + return + } + if (er) return cb(errState = er) + if (--n === 0) { + options.rmdir(p, cb) + } + }) + }) + }) +} + +// this looks simpler, and is strictly *faster*, but will +// tie up the JavaScript thread and fail on excessively +// deep directory trees. +function rimrafSync (p, options) { + let st + + options = options || {} + defaults(options) + + assert(p, 'rimraf: missing path') + assert.strictEqual(typeof p, 'string', 'rimraf: path should be a string') + assert(options, 'rimraf: missing options') + assert.strictEqual(typeof options, 'object', 'rimraf: options should be object') + + try { + st = options.lstatSync(p) + } catch (er) { + if (er.code === 'ENOENT') { + return + } + + // Windows can EPERM on stat. Life is suffering. + if (er.code === 'EPERM' && isWindows) { + fixWinEPERMSync(p, options, er) + } + } + + try { + // sunos lets the root user unlink directories, which is... weird. + if (st && st.isDirectory()) { + rmdirSync(p, options, null) + } else { + options.unlinkSync(p) + } + } catch (er) { + if (er.code === 'ENOENT') { + return + } else if (er.code === 'EPERM') { + return isWindows ? fixWinEPERMSync(p, options, er) : rmdirSync(p, options, er) + } else if (er.code !== 'EISDIR') { + throw er + } + rmdirSync(p, options, er) + } +} + +function rmdirSync (p, options, originalEr) { + assert(p) + assert(options) + + try { + options.rmdirSync(p) + } catch (er) { + if (er.code === 'ENOTDIR') { + throw originalEr + } else if (er.code === 'ENOTEMPTY' || er.code === 'EEXIST' || er.code === 'EPERM') { + rmkidsSync(p, options) + } else if (er.code !== 'ENOENT') { + throw er + } + } +} + +function rmkidsSync (p, options) { + assert(p) + assert(options) + options.readdirSync(p).forEach(f => rimrafSync(path.join(p, f), options)) + + if (isWindows) { + // We only end up here once we got ENOTEMPTY at least once, and + // at this point, we are guaranteed to have removed all the kids. + // So, we know that it won't be ENOENT or ENOTDIR or anything else. + // try really hard to delete stuff on windows, because it has a + // PROFOUNDLY annoying habit of not closing handles promptly when + // files are deleted, resulting in spurious ENOTEMPTY errors. + const startTime = Date.now() + do { + try { + const ret = options.rmdirSync(p, options) + return ret + } catch {} + } while (Date.now() - startTime < 500) // give up after 500ms + } else { + const ret = options.rmdirSync(p, options) + return ret + } +} + +module.exports = rimraf +rimraf.sync = rimrafSync diff --git a/tools/ui/node_modules/fs-extra/lib/util/stat.js b/tools/ui/node_modules/fs-extra/lib/util/stat.js new file mode 100644 index 0000000000000000000000000000000000000000..0b1c1b09636b75e896d0aeccea48ec7976c47547 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/util/stat.js @@ -0,0 +1,139 @@ +'use strict' + +const fs = require('../fs') +const path = require('path') +const util = require('util') +const atLeastNode = require('at-least-node') + +const nodeSupportsBigInt = atLeastNode('10.5.0') +const stat = (file) => nodeSupportsBigInt ? fs.stat(file, { bigint: true }) : fs.stat(file) +const statSync = (file) => nodeSupportsBigInt ? fs.statSync(file, { bigint: true }) : fs.statSync(file) + +function getStats (src, dest) { + return Promise.all([ + stat(src), + stat(dest).catch(err => { + if (err.code === 'ENOENT') return null + throw err + }) + ]).then(([srcStat, destStat]) => ({ srcStat, destStat })) +} + +function getStatsSync (src, dest) { + let destStat + const srcStat = statSync(src) + try { + destStat = statSync(dest) + } catch (err) { + if (err.code === 'ENOENT') return { srcStat, destStat: null } + throw err + } + return { srcStat, destStat } +} + +function checkPaths (src, dest, funcName, cb) { + util.callbackify(getStats)(src, dest, (err, stats) => { + if (err) return cb(err) + const { srcStat, destStat } = stats + if (destStat && areIdentical(srcStat, destStat)) { + return cb(new Error('Source and destination must not be the same.')) + } + if (srcStat.isDirectory() && isSrcSubdir(src, dest)) { + return cb(new Error(errMsg(src, dest, funcName))) + } + return cb(null, { srcStat, destStat }) + }) +} + +function checkPathsSync (src, dest, funcName) { + const { srcStat, destStat } = getStatsSync(src, dest) + if (destStat && areIdentical(srcStat, destStat)) { + throw new Error('Source and destination must not be the same.') + } + if (srcStat.isDirectory() && isSrcSubdir(src, dest)) { + throw new Error(errMsg(src, dest, funcName)) + } + return { srcStat, destStat } +} + +// recursively check if dest parent is a subdirectory of src. +// It works for all file types including symlinks since it +// checks the src and dest inodes. It starts from the deepest +// parent and stops once it reaches the src parent or the root path. +function checkParentPaths (src, srcStat, dest, funcName, cb) { + const srcParent = path.resolve(path.dirname(src)) + const destParent = path.resolve(path.dirname(dest)) + if (destParent === srcParent || destParent === path.parse(destParent).root) return cb() + const callback = (err, destStat) => { + if (err) { + if (err.code === 'ENOENT') return cb() + return cb(err) + } + if (areIdentical(srcStat, destStat)) { + return cb(new Error(errMsg(src, dest, funcName))) + } + return checkParentPaths(src, srcStat, destParent, funcName, cb) + } + if (nodeSupportsBigInt) fs.stat(destParent, { bigint: true }, callback) + else fs.stat(destParent, callback) +} + +function checkParentPathsSync (src, srcStat, dest, funcName) { + const srcParent = path.resolve(path.dirname(src)) + const destParent = path.resolve(path.dirname(dest)) + if (destParent === srcParent || destParent === path.parse(destParent).root) return + let destStat + try { + destStat = statSync(destParent) + } catch (err) { + if (err.code === 'ENOENT') return + throw err + } + if (areIdentical(srcStat, destStat)) { + throw new Error(errMsg(src, dest, funcName)) + } + return checkParentPathsSync(src, srcStat, destParent, funcName) +} + +function areIdentical (srcStat, destStat) { + if (destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev) { + if (nodeSupportsBigInt || destStat.ino < Number.MAX_SAFE_INTEGER) { + // definitive answer + return true + } + // Use additional heuristics if we can't use 'bigint'. + // Different 'ino' could be represented the same if they are >= Number.MAX_SAFE_INTEGER + // See issue 657 + if (destStat.size === srcStat.size && + destStat.mode === srcStat.mode && + destStat.nlink === srcStat.nlink && + destStat.atimeMs === srcStat.atimeMs && + destStat.mtimeMs === srcStat.mtimeMs && + destStat.ctimeMs === srcStat.ctimeMs && + destStat.birthtimeMs === srcStat.birthtimeMs) { + // heuristic answer + return true + } + } + return false +} + +// return true if dest is a subdir of src, otherwise false. +// It only checks the path strings. +function isSrcSubdir (src, dest) { + const srcArr = path.resolve(src).split(path.sep).filter(i => i) + const destArr = path.resolve(dest).split(path.sep).filter(i => i) + return srcArr.reduce((acc, cur, i) => acc && destArr[i] === cur, true) +} + +function errMsg (src, dest, funcName) { + return `Cannot ${funcName} '${src}' to a subdirectory of itself, '${dest}'.` +} + +module.exports = { + checkPaths, + checkPathsSync, + checkParentPaths, + checkParentPathsSync, + isSrcSubdir +} diff --git a/tools/ui/node_modules/fs-extra/lib/util/utimes.js b/tools/ui/node_modules/fs-extra/lib/util/utimes.js new file mode 100644 index 0000000000000000000000000000000000000000..75395deff42fa751456e99b9fd4a7b2426c7eeac --- /dev/null +++ b/tools/ui/node_modules/fs-extra/lib/util/utimes.js @@ -0,0 +1,26 @@ +'use strict' + +const fs = require('graceful-fs') + +function utimesMillis (path, atime, mtime, callback) { + // if (!HAS_MILLIS_RES) return fs.utimes(path, atime, mtime, callback) + fs.open(path, 'r+', (err, fd) => { + if (err) return callback(err) + fs.futimes(fd, atime, mtime, futimesErr => { + fs.close(fd, closeErr => { + if (callback) callback(futimesErr || closeErr) + }) + }) + }) +} + +function utimesMillisSync (path, atime, mtime) { + const fd = fs.openSync(path, 'r+') + fs.futimesSync(fd, atime, mtime) + return fs.closeSync(fd) +} + +module.exports = { + utimesMillis, + utimesMillisSync +} diff --git a/tools/ui/node_modules/fs-extra/package.json b/tools/ui/node_modules/fs-extra/package.json new file mode 100644 index 0000000000000000000000000000000000000000..6f7d8ddb7a601de0d00de6bf96fbcc19820dc387 --- /dev/null +++ b/tools/ui/node_modules/fs-extra/package.json @@ -0,0 +1,70 @@ +{ + "name": "fs-extra", + "version": "9.1.0", + "description": "fs-extra contains methods that aren't included in the vanilla Node.js fs package. Such as recursive mkdir, copy, and remove.", + "engines": { + "node": ">=10" + }, + "homepage": "https://github.com/jprichardson/node-fs-extra", + "repository": { + "type": "git", + "url": "https://github.com/jprichardson/node-fs-extra" + }, + "keywords": [ + "fs", + "file", + "file system", + "copy", + "directory", + "extra", + "mkdirp", + "mkdir", + "mkdirs", + "recursive", + "json", + "read", + "write", + "extra", + "delete", + "remove", + "touch", + "create", + "text", + "output", + "move", + "promise" + ], + "author": "JP Richardson ", + "license": "MIT", + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "devDependencies": { + "coveralls": "^3.0.0", + "klaw": "^2.1.1", + "klaw-sync": "^3.0.2", + "minimist": "^1.1.1", + "mocha": "^5.0.5", + "nyc": "^15.0.0", + "proxyquire": "^2.0.1", + "read-dir-files": "^0.1.1", + "standard": "^14.1.0" + }, + "main": "./lib/index.js", + "files": [ + "lib/", + "!lib/**/__tests__/" + ], + "scripts": { + "full-ci": "npm run lint && npm run coverage", + "coverage": "nyc -r lcovonly npm run unit", + "coveralls": "coveralls < coverage/lcov.info", + "lint": "standard", + "test-find": "find ./lib/**/__tests__ -name *.test.js | xargs mocha", + "test": "npm run lint && npm run unit", + "unit": "node test.js" + } +} diff --git a/tools/ui/node_modules/function-bind/.eslintrc b/tools/ui/node_modules/function-bind/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..71a054fd370a627af5171153377e7c78ba8937f9 --- /dev/null +++ b/tools/ui/node_modules/function-bind/.eslintrc @@ -0,0 +1,21 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "func-name-matching": 0, + "indent": [2, 4], + "no-new-func": [1], + }, + + "overrides": [ + { + "files": "test/**", + "rules": { + "max-lines-per-function": 0, + "strict": [0] + }, + }, + ], +} diff --git a/tools/ui/node_modules/function-bind/.github/FUNDING.yml b/tools/ui/node_modules/function-bind/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..74482195934a98d0ce03d92cdabbc8a36e647d6f --- /dev/null +++ b/tools/ui/node_modules/function-bind/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/function-bind +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/function-bind/.github/SECURITY.md b/tools/ui/node_modules/function-bind/.github/SECURITY.md new file mode 100644 index 0000000000000000000000000000000000000000..82e4285adc6285693cd6c06af02d606e09dd8fcd --- /dev/null +++ b/tools/ui/node_modules/function-bind/.github/SECURITY.md @@ -0,0 +1,3 @@ +# Security + +Please email [@ljharb](https://github.com/ljharb) or see https://tidelift.com/security if you have a potential security vulnerability to report. diff --git a/tools/ui/node_modules/function-bind/.nycrc b/tools/ui/node_modules/function-bind/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..1826526e091b89c896e7099ccd891db79165e329 --- /dev/null +++ b/tools/ui/node_modules/function-bind/.nycrc @@ -0,0 +1,13 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "lines": 86, + "statements": 85.93, + "functions": 82.43, + "branches": 76.06, + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/function-bind/CHANGELOG.md b/tools/ui/node_modules/function-bind/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..f9e6cc078dadd58957c92af75542453c18169d73 --- /dev/null +++ b/tools/ui/node_modules/function-bind/CHANGELOG.md @@ -0,0 +1,136 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.1.2](https://github.com/ljharb/function-bind/compare/v1.1.1...v1.1.2) - 2023-10-12 + +### Merged + +- Point to the correct file [`#16`](https://github.com/ljharb/function-bind/pull/16) + +### Commits + +- [Tests] migrate tests to Github Actions [`4f8b57c`](https://github.com/ljharb/function-bind/commit/4f8b57c02f2011fe9ae353d5e74e8745f0988af8) +- [Tests] remove `jscs` [`90eb2ed`](https://github.com/ljharb/function-bind/commit/90eb2edbeefd5b76cd6c3a482ea3454db169b31f) +- [meta] update `.gitignore` [`53fcdc3`](https://github.com/ljharb/function-bind/commit/53fcdc371cd66634d6e9b71c836a50f437e89fed) +- [Tests] up to `node` `v11.10`, `v10.15`, `v9.11`, `v8.15`, `v6.16`, `v4.9`; use `nvm install-latest-npm`; run audit script in tests [`1fe8f6e`](https://github.com/ljharb/function-bind/commit/1fe8f6e9aed0dfa8d8b3cdbd00c7f5ea0cd2b36e) +- [meta] add `auto-changelog` [`1921fcb`](https://github.com/ljharb/function-bind/commit/1921fcb5b416b63ffc4acad051b6aad5722f777d) +- [Robustness] remove runtime dependency on all builtins except `.apply` [`f743e61`](https://github.com/ljharb/function-bind/commit/f743e61aa6bb2360358c04d4884c9db853d118b7) +- Docs: enable badges; update wording [`503cb12`](https://github.com/ljharb/function-bind/commit/503cb12d998b5f91822776c73332c7adcd6355dd) +- [readme] update badges [`290c5db`](https://github.com/ljharb/function-bind/commit/290c5dbbbda7264efaeb886552a374b869a4bb48) +- [Tests] switch to nyc for coverage [`ea360ba`](https://github.com/ljharb/function-bind/commit/ea360ba907fc2601ed18d01a3827fa2d3533cdf8) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` [`cae5e9e`](https://github.com/ljharb/function-bind/commit/cae5e9e07a5578dc6df26c03ee22851ce05b943c) +- [meta] add `funding` field; create FUNDING.yml [`c9f4274`](https://github.com/ljharb/function-bind/commit/c9f4274aa80ea3aae9657a3938fdba41a3b04ca6) +- [Tests] fix eslint errors from #15 [`f69aaa2`](https://github.com/ljharb/function-bind/commit/f69aaa2beb2fdab4415bfb885760a699d0b9c964) +- [actions] fix permissions [`99a0cd9`](https://github.com/ljharb/function-bind/commit/99a0cd9f3b5bac223a0d572f081834cd73314be7) +- [meta] use `npmignore` to autogenerate an npmignore file [`f03b524`](https://github.com/ljharb/function-bind/commit/f03b524ca91f75a109a5d062f029122c86ecd1ae) +- [Dev Deps] update `@ljharb/eslint‑config`, `eslint`, `tape` [`7af9300`](https://github.com/ljharb/function-bind/commit/7af930023ae2ce7645489532821e4fbbcd7a2280) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `covert`, `tape` [`64a9127`](https://github.com/ljharb/function-bind/commit/64a9127ab0bd331b93d6572eaf6e9971967fc08c) +- [Tests] use `aud` instead of `npm audit` [`e75069c`](https://github.com/ljharb/function-bind/commit/e75069c50010a8fcce2a9ce2324934c35fdb4386) +- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `tape` [`d03555c`](https://github.com/ljharb/function-bind/commit/d03555ca59dea3b71ce710045e4303b9e2619e28) +- [meta] add `safe-publish-latest` [`9c8f809`](https://github.com/ljharb/function-bind/commit/9c8f8092aed027d7e80c94f517aa892385b64f09) +- [Dev Deps] update `@ljharb/eslint-config`, `tape` [`baf6893`](https://github.com/ljharb/function-bind/commit/baf6893e27f5b59abe88bc1995e6f6ed1e527397) +- [meta] create SECURITY.md [`4db1779`](https://github.com/ljharb/function-bind/commit/4db17799f1f28ae294cb95e0081ca2b591c3911b) +- [Tests] add `npm run audit` [`c8b38ec`](https://github.com/ljharb/function-bind/commit/c8b38ec40ed3f85dabdee40ed4148f1748375bc2) +- Revert "Point to the correct file" [`05cdf0f`](https://github.com/ljharb/function-bind/commit/05cdf0fa205c6a3c5ba40bbedd1dfa9874f915c9) + +## [v1.1.1](https://github.com/ljharb/function-bind/compare/v1.1.0...v1.1.1) - 2017-08-28 + +### Commits + +- [Tests] up to `node` `v8`; newer npm breaks on older node; fix scripts [`817f7d2`](https://github.com/ljharb/function-bind/commit/817f7d28470fdbff8ef608d4d565dd4d1430bc5e) +- [Dev Deps] update `eslint`, `jscs`, `tape`, `@ljharb/eslint-config` [`854288b`](https://github.com/ljharb/function-bind/commit/854288b1b6f5c555f89aceb9eff1152510262084) +- [Dev Deps] update `tape`, `jscs`, `eslint`, `@ljharb/eslint-config` [`83e639f`](https://github.com/ljharb/function-bind/commit/83e639ff74e6cd6921285bccec22c1bcf72311bd) +- Only apps should have lockfiles [`5ed97f5`](https://github.com/ljharb/function-bind/commit/5ed97f51235c17774e0832e122abda0f3229c908) +- Use a SPDX-compliant “license” field. [`5feefea`](https://github.com/ljharb/function-bind/commit/5feefea0dc0193993e83e5df01ded424403a5381) + +## [v1.1.0](https://github.com/ljharb/function-bind/compare/v1.0.2...v1.1.0) - 2016-02-14 + +### Commits + +- Update `eslint`, `tape`; use my personal shared `eslint` config [`9c9062a`](https://github.com/ljharb/function-bind/commit/9c9062abbe9dd70b59ea2c3a3c3a81f29b457097) +- Add `npm run eslint` [`dd96c56`](https://github.com/ljharb/function-bind/commit/dd96c56720034a3c1ffee10b8a59a6f7c53e24ad) +- [New] return the native `bind` when available. [`82186e0`](https://github.com/ljharb/function-bind/commit/82186e03d73e580f95ff167e03f3582bed90ed72) +- [Dev Deps] update `tape`, `jscs`, `eslint`, `@ljharb/eslint-config` [`a3dd767`](https://github.com/ljharb/function-bind/commit/a3dd76720c795cb7f4586b0544efabf8aa107b8b) +- Update `eslint` [`3dae2f7`](https://github.com/ljharb/function-bind/commit/3dae2f7423de30a2d20313ddb1edc19660142fe9) +- Update `tape`, `covert`, `jscs` [`a181eee`](https://github.com/ljharb/function-bind/commit/a181eee0cfa24eb229c6e843a971f36e060a2f6a) +- [Tests] up to `node` `v5.6`, `v4.3` [`964929a`](https://github.com/ljharb/function-bind/commit/964929a6a4ddb36fb128de2bcc20af5e4f22e1ed) +- Test up to `io.js` `v2.1` [`2be7310`](https://github.com/ljharb/function-bind/commit/2be7310f2f74886a7124ca925be411117d41d5ea) +- Update `tape`, `jscs`, `eslint`, `@ljharb/eslint-config` [`45f3d68`](https://github.com/ljharb/function-bind/commit/45f3d6865c6ca93726abcef54febe009087af101) +- [Dev Deps] update `tape`, `jscs` [`6e1340d`](https://github.com/ljharb/function-bind/commit/6e1340d94642deaecad3e717825db641af4f8b1f) +- [Tests] up to `io.js` `v3.3`, `node` `v4.1` [`d9bad2b`](https://github.com/ljharb/function-bind/commit/d9bad2b778b1b3a6dd2876087b88b3acf319f8cc) +- Update `eslint` [`935590c`](https://github.com/ljharb/function-bind/commit/935590caa024ab356102e4858e8fc315b2ccc446) +- [Dev Deps] update `jscs`, `eslint`, `@ljharb/eslint-config` [`8c9a1ef`](https://github.com/ljharb/function-bind/commit/8c9a1efd848e5167887aa8501857a0940a480c57) +- Test on `io.js` `v2.2` [`9a3a38c`](https://github.com/ljharb/function-bind/commit/9a3a38c92013aed6e108666e7bd40969b84ac86e) +- Run `travis-ci` tests on `iojs` and `node` v0.12; speed up builds; allow 0.8 failures. [`69afc26`](https://github.com/ljharb/function-bind/commit/69afc2617405b147dd2a8d8ae73ca9e9283f18b4) +- [Dev Deps] Update `tape`, `eslint` [`36c1be0`](https://github.com/ljharb/function-bind/commit/36c1be0ab12b45fe5df6b0fdb01a5d5137fd0115) +- Update `tape`, `jscs` [`98d8303`](https://github.com/ljharb/function-bind/commit/98d8303cd5ca1c6b8f985469f86b0d44d7d45f6e) +- Update `jscs` [`9633a4e`](https://github.com/ljharb/function-bind/commit/9633a4e9fbf82051c240855166e468ba8ba0846f) +- Update `tape`, `jscs` [`c80ef0f`](https://github.com/ljharb/function-bind/commit/c80ef0f46efc9791e76fa50de4414092ac147831) +- Test up to `io.js` `v3.0` [`7e2c853`](https://github.com/ljharb/function-bind/commit/7e2c8537d52ab9cf5a655755561d8917684c0df4) +- Test on `io.js` `v2.4` [`5a199a2`](https://github.com/ljharb/function-bind/commit/5a199a27ba46795ba5eaf0845d07d4b8232895c9) +- Test on `io.js` `v2.3` [`a511b88`](https://github.com/ljharb/function-bind/commit/a511b8896de0bddf3b56862daa416c701f4d0453) +- Fixing a typo from 822b4e1938db02dc9584aa434fd3a45cb20caf43 [`732d6b6`](https://github.com/ljharb/function-bind/commit/732d6b63a9b33b45230e630dbcac7a10855d3266) +- Update `jscs` [`da52a48`](https://github.com/ljharb/function-bind/commit/da52a4886c06d6490f46ae30b15e4163ba08905d) +- Lock covert to v1.0.0. [`d6150fd`](https://github.com/ljharb/function-bind/commit/d6150fda1e6f486718ebdeff823333d9e48e7430) + +## [v1.0.2](https://github.com/ljharb/function-bind/compare/v1.0.1...v1.0.2) - 2014-10-04 + +## [v1.0.1](https://github.com/ljharb/function-bind/compare/v1.0.0...v1.0.1) - 2014-10-03 + +### Merged + +- make CI build faster [`#3`](https://github.com/ljharb/function-bind/pull/3) + +### Commits + +- Using my standard jscs.json [`d8ee94c`](https://github.com/ljharb/function-bind/commit/d8ee94c993eff0a84cf5744fe6a29627f5cffa1a) +- Adding `npm run lint` [`7571ab7`](https://github.com/ljharb/function-bind/commit/7571ab7dfdbd99b25a1dbb2d232622bd6f4f9c10) +- Using consistent indentation [`e91a1b1`](https://github.com/ljharb/function-bind/commit/e91a1b13a61e99ec1e530e299b55508f74218a95) +- Updating jscs [`7e17892`](https://github.com/ljharb/function-bind/commit/7e1789284bc629bc9c1547a61c9b227bbd8c7a65) +- Using consistent quotes [`c50b57f`](https://github.com/ljharb/function-bind/commit/c50b57fcd1c5ec38320979c837006069ebe02b77) +- Adding keywords [`cb94631`](https://github.com/ljharb/function-bind/commit/cb946314eed35f21186a25fb42fc118772f9ee00) +- Directly export a function expression instead of using a declaration, and relying on hoisting. [`5a33c5f`](https://github.com/ljharb/function-bind/commit/5a33c5f45642de180e0d207110bf7d1843ceb87c) +- Naming npm URL and badge in README; use SVG [`2aef8fc`](https://github.com/ljharb/function-bind/commit/2aef8fcb79d54e63a58ae557c4e60949e05d5e16) +- Naming deps URLs in README [`04228d7`](https://github.com/ljharb/function-bind/commit/04228d766670ee45ca24e98345c1f6a7621065b5) +- Naming travis-ci URLs in README; using SVG [`62c810c`](https://github.com/ljharb/function-bind/commit/62c810c2f54ced956cd4d4ab7b793055addfe36e) +- Make sure functions are invoked correctly (also passing coverage tests) [`2b289b4`](https://github.com/ljharb/function-bind/commit/2b289b4dfbf037ffcfa4dc95eb540f6165e9e43a) +- Removing the strict mode pragmas; they make tests fail. [`1aa701d`](https://github.com/ljharb/function-bind/commit/1aa701d199ddc3782476e8f7eef82679be97b845) +- Adding myself as a contributor [`85fd57b`](https://github.com/ljharb/function-bind/commit/85fd57b0860e5a7af42de9a287f3f265fc6d72fc) +- Adding strict mode pragmas [`915b08e`](https://github.com/ljharb/function-bind/commit/915b08e084c86a722eafe7245e21db74aa21ca4c) +- Adding devDeps URLs to README [`4ccc731`](https://github.com/ljharb/function-bind/commit/4ccc73112c1769859e4ca3076caf4086b3cba2cd) +- Fixing the description. [`a7a472c`](https://github.com/ljharb/function-bind/commit/a7a472cf649af515c635cf560fc478fbe48999c8) +- Using a function expression instead of a function declaration. [`b5d3e4e`](https://github.com/ljharb/function-bind/commit/b5d3e4ea6aaffc63888953eeb1fbc7ff45f1fa14) +- Updating tape [`f086be6`](https://github.com/ljharb/function-bind/commit/f086be6029fb56dde61a258c1340600fa174d1e0) +- Updating jscs [`5f9bdb3`](https://github.com/ljharb/function-bind/commit/5f9bdb375ab13ba48f30852aab94029520c54d71) +- Updating jscs [`9b409ba`](https://github.com/ljharb/function-bind/commit/9b409ba6118e23395a4e5d83ef39152aab9d3bfc) +- Run coverage as part of tests. [`8e1b6d4`](https://github.com/ljharb/function-bind/commit/8e1b6d459f047d1bd4fee814e01247c984c80bd0) +- Run linter as part of tests [`c1ca83f`](https://github.com/ljharb/function-bind/commit/c1ca83f832df94587d09e621beba682fabfaa987) +- Updating covert [`701e837`](https://github.com/ljharb/function-bind/commit/701e83774b57b4d3ef631e1948143f43a72f4bb9) + +## [v1.0.0](https://github.com/ljharb/function-bind/compare/v0.2.0...v1.0.0) - 2014-08-09 + +### Commits + +- Make sure old and unstable nodes don't fail Travis [`27adca3`](https://github.com/ljharb/function-bind/commit/27adca34a4ab6ad67b6dfde43942a1b103ce4d75) +- Fixing an issue when the bound function is called as a constructor in ES3. [`e20122d`](https://github.com/ljharb/function-bind/commit/e20122d267d92ce553859b280cbbea5d27c07731) +- Adding `npm run coverage` [`a2e29c4`](https://github.com/ljharb/function-bind/commit/a2e29c4ecaef9e2f6cd1603e868c139073375502) +- Updating tape [`b741168`](https://github.com/ljharb/function-bind/commit/b741168b12b235b1717ff696087645526b69213c) +- Upgrading tape [`63631a0`](https://github.com/ljharb/function-bind/commit/63631a04c7fbe97cc2fa61829cc27246d6986f74) +- Updating tape [`363cb46`](https://github.com/ljharb/function-bind/commit/363cb46dafb23cb3e347729a22f9448051d78464) + +## v0.2.0 - 2014-03-23 + +### Commits + +- Updating test coverage to match es5-shim. [`aa94d44`](https://github.com/ljharb/function-bind/commit/aa94d44b8f9d7f69f10e060db7709aa7a694e5d4) +- initial [`942ee07`](https://github.com/ljharb/function-bind/commit/942ee07e94e542d91798137bc4b80b926137e066) +- Setting the bound function's length properly. [`079f46a`](https://github.com/ljharb/function-bind/commit/079f46a2d3515b7c0b308c2c13fceb641f97ca25) +- Ensuring that some older browsers will throw when given a regex. [`36ac55b`](https://github.com/ljharb/function-bind/commit/36ac55b87f460d4330253c92870aa26fbfe8227f) +- Removing npm scripts that don't have dependencies [`9d2be60`](https://github.com/ljharb/function-bind/commit/9d2be600002cb8bc8606f8f3585ad3e05868c750) +- Updating tape [`297a4ac`](https://github.com/ljharb/function-bind/commit/297a4acc5464db381940aafb194d1c88f4e678f3) +- Skipping length tests for now. [`d9891ea`](https://github.com/ljharb/function-bind/commit/d9891ea4d2aaffa69f408339cdd61ff740f70565) +- don't take my tea [`dccd930`](https://github.com/ljharb/function-bind/commit/dccd930bfd60ea10cb178d28c97550c3bc8c1e07) diff --git a/tools/ui/node_modules/function-bind/LICENSE b/tools/ui/node_modules/function-bind/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..62d6d237ff179b118746a64a34967f7ff4b5dff8 --- /dev/null +++ b/tools/ui/node_modules/function-bind/LICENSE @@ -0,0 +1,20 @@ +Copyright (c) 2013 Raynos. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + diff --git a/tools/ui/node_modules/function-bind/README.md b/tools/ui/node_modules/function-bind/README.md new file mode 100644 index 0000000000000000000000000000000000000000..814c20b5a9e3c97f41dde308939b358f9ed93931 --- /dev/null +++ b/tools/ui/node_modules/function-bind/README.md @@ -0,0 +1,46 @@ +# function-bind [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] + +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +Implementation of function.prototype.bind + +Old versions of phantomjs, Internet Explorer < 9, and node < 0.6 don't support `Function.prototype.bind`. + +## Example + +```js +Function.prototype.bind = require("function-bind") +``` + +## Installation + +`npm install function-bind` + +## Contributors + + - Raynos + +## MIT Licenced + +[package-url]: https://npmjs.org/package/function-bind +[npm-version-svg]: https://versionbadg.es/Raynos/function-bind.svg +[deps-svg]: https://david-dm.org/Raynos/function-bind.svg +[deps-url]: https://david-dm.org/Raynos/function-bind +[dev-deps-svg]: https://david-dm.org/Raynos/function-bind/dev-status.svg +[dev-deps-url]: https://david-dm.org/Raynos/function-bind#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/function-bind.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/function-bind.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/function-bind.svg +[downloads-url]: https://npm-stat.com/charts.html?package=function-bind +[codecov-image]: https://codecov.io/gh/Raynos/function-bind/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/Raynos/function-bind/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/Raynos/function-bind +[actions-url]: https://github.com/Raynos/function-bind/actions diff --git a/tools/ui/node_modules/function-bind/implementation.js b/tools/ui/node_modules/function-bind/implementation.js new file mode 100644 index 0000000000000000000000000000000000000000..fd4384cc0c34ce3e1e411bc8b0557680cf000eff --- /dev/null +++ b/tools/ui/node_modules/function-bind/implementation.js @@ -0,0 +1,84 @@ +'use strict'; + +/* eslint no-invalid-this: 1 */ + +var ERROR_MESSAGE = 'Function.prototype.bind called on incompatible '; +var toStr = Object.prototype.toString; +var max = Math.max; +var funcType = '[object Function]'; + +var concatty = function concatty(a, b) { + var arr = []; + + for (var i = 0; i < a.length; i += 1) { + arr[i] = a[i]; + } + for (var j = 0; j < b.length; j += 1) { + arr[j + a.length] = b[j]; + } + + return arr; +}; + +var slicy = function slicy(arrLike, offset) { + var arr = []; + for (var i = offset || 0, j = 0; i < arrLike.length; i += 1, j += 1) { + arr[j] = arrLike[i]; + } + return arr; +}; + +var joiny = function (arr, joiner) { + var str = ''; + for (var i = 0; i < arr.length; i += 1) { + str += arr[i]; + if (i + 1 < arr.length) { + str += joiner; + } + } + return str; +}; + +module.exports = function bind(that) { + var target = this; + if (typeof target !== 'function' || toStr.apply(target) !== funcType) { + throw new TypeError(ERROR_MESSAGE + target); + } + var args = slicy(arguments, 1); + + var bound; + var binder = function () { + if (this instanceof bound) { + var result = target.apply( + this, + concatty(args, arguments) + ); + if (Object(result) === result) { + return result; + } + return this; + } + return target.apply( + that, + concatty(args, arguments) + ); + + }; + + var boundLength = max(0, target.length - args.length); + var boundArgs = []; + for (var i = 0; i < boundLength; i++) { + boundArgs[i] = '$' + i; + } + + bound = Function('binder', 'return function (' + joiny(boundArgs, ',') + '){ return binder.apply(this,arguments); }')(binder); + + if (target.prototype) { + var Empty = function Empty() {}; + Empty.prototype = target.prototype; + bound.prototype = new Empty(); + Empty.prototype = null; + } + + return bound; +}; diff --git a/tools/ui/node_modules/function-bind/index.js b/tools/ui/node_modules/function-bind/index.js new file mode 100644 index 0000000000000000000000000000000000000000..3bb6b9609889f8131b2d6732ff1606e01e1365b2 --- /dev/null +++ b/tools/ui/node_modules/function-bind/index.js @@ -0,0 +1,5 @@ +'use strict'; + +var implementation = require('./implementation'); + +module.exports = Function.prototype.bind || implementation; diff --git a/tools/ui/node_modules/function-bind/package.json b/tools/ui/node_modules/function-bind/package.json new file mode 100644 index 0000000000000000000000000000000000000000..618596389779061eb7f6f34edc61add4a517ca4f --- /dev/null +++ b/tools/ui/node_modules/function-bind/package.json @@ -0,0 +1,87 @@ +{ + "name": "function-bind", + "version": "1.1.2", + "description": "Implementation of Function.prototype.bind", + "keywords": [ + "function", + "bind", + "shim", + "es5" + ], + "author": "Raynos ", + "repository": { + "type": "git", + "url": "https://github.com/Raynos/function-bind.git" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "main": "index", + "homepage": "https://github.com/Raynos/function-bind", + "contributors": [ + { + "name": "Raynos" + }, + { + "name": "Jordan Harband", + "url": "https://github.com/ljharb" + } + ], + "bugs": { + "url": "https://github.com/Raynos/function-bind/issues", + "email": "raynos2@gmail.com" + }, + "devDependencies": { + "@ljharb/eslint-config": "^21.1.0", + "aud": "^2.0.3", + "auto-changelog": "^2.4.0", + "eslint": "=8.8.0", + "in-publish": "^2.0.1", + "npmignore": "^0.3.0", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "tape": "^5.7.1" + }, + "license": "MIT", + "scripts": { + "prepublishOnly": "safe-publish-latest", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepack": "npmignore --auto --commentLines=autogenerated", + "pretest": "npm run lint", + "test": "npm run tests-only", + "posttest": "aud --production", + "tests-only": "nyc tape 'test/**/*.js'", + "lint": "eslint --ext=js,mjs .", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "testling": { + "files": "test/index.js", + "browsers": [ + "ie/8..latest", + "firefox/16..latest", + "firefox/nightly", + "chrome/22..latest", + "chrome/canary", + "opera/12..latest", + "opera/next", + "safari/5.1..latest", + "ipad/6.0..latest", + "iphone/6.0..latest", + "android-browser/4.2..latest" + ] + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + } +} diff --git a/tools/ui/node_modules/function-bind/test/.eslintrc b/tools/ui/node_modules/function-bind/test/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..8a56d5b72fb008043cc69939648790ef482cdab8 --- /dev/null +++ b/tools/ui/node_modules/function-bind/test/.eslintrc @@ -0,0 +1,9 @@ +{ + "rules": { + "array-bracket-newline": 0, + "array-element-newline": 0, + "max-statements-per-line": [2, { "max": 2 }], + "no-invalid-this": 0, + "no-magic-numbers": 0, + } +} diff --git a/tools/ui/node_modules/function-bind/test/index.js b/tools/ui/node_modules/function-bind/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..2edecce2f0fa5adcc88ebc609440221621048c05 --- /dev/null +++ b/tools/ui/node_modules/function-bind/test/index.js @@ -0,0 +1,252 @@ +// jscs:disable requireUseStrict + +var test = require('tape'); + +var functionBind = require('../implementation'); +var getCurrentContext = function () { return this; }; + +test('functionBind is a function', function (t) { + t.equal(typeof functionBind, 'function'); + t.end(); +}); + +test('non-functions', function (t) { + var nonFunctions = [true, false, [], {}, 42, 'foo', NaN, /a/g]; + t.plan(nonFunctions.length); + for (var i = 0; i < nonFunctions.length; ++i) { + try { functionBind.call(nonFunctions[i]); } catch (ex) { + t.ok(ex instanceof TypeError, 'throws when given ' + String(nonFunctions[i])); + } + } + t.end(); +}); + +test('without a context', function (t) { + t.test('binds properly', function (st) { + var args, context; + var namespace = { + func: functionBind.call(function () { + args = Array.prototype.slice.call(arguments); + context = this; + }) + }; + namespace.func(1, 2, 3); + st.deepEqual(args, [1, 2, 3]); + st.equal(context, getCurrentContext.call()); + st.end(); + }); + + t.test('binds properly, and still supplies bound arguments', function (st) { + var args, context; + var namespace = { + func: functionBind.call(function () { + args = Array.prototype.slice.call(arguments); + context = this; + }, undefined, 1, 2, 3) + }; + namespace.func(4, 5, 6); + st.deepEqual(args, [1, 2, 3, 4, 5, 6]); + st.equal(context, getCurrentContext.call()); + st.end(); + }); + + t.test('returns properly', function (st) { + var args; + var namespace = { + func: functionBind.call(function () { + args = Array.prototype.slice.call(arguments); + return this; + }, null) + }; + var context = namespace.func(1, 2, 3); + st.equal(context, getCurrentContext.call(), 'returned context is namespaced context'); + st.deepEqual(args, [1, 2, 3], 'passed arguments are correct'); + st.end(); + }); + + t.test('returns properly with bound arguments', function (st) { + var args; + var namespace = { + func: functionBind.call(function () { + args = Array.prototype.slice.call(arguments); + return this; + }, null, 1, 2, 3) + }; + var context = namespace.func(4, 5, 6); + st.equal(context, getCurrentContext.call(), 'returned context is namespaced context'); + st.deepEqual(args, [1, 2, 3, 4, 5, 6], 'passed arguments are correct'); + st.end(); + }); + + t.test('called as a constructor', function (st) { + var thunkify = function (value) { + return function () { return value; }; + }; + st.test('returns object value', function (sst) { + var expectedReturnValue = [1, 2, 3]; + var Constructor = functionBind.call(thunkify(expectedReturnValue), null); + var result = new Constructor(); + sst.equal(result, expectedReturnValue); + sst.end(); + }); + + st.test('does not return primitive value', function (sst) { + var Constructor = functionBind.call(thunkify(42), null); + var result = new Constructor(); + sst.notEqual(result, 42); + sst.end(); + }); + + st.test('object from bound constructor is instance of original and bound constructor', function (sst) { + var A = function (x) { + this.name = x || 'A'; + }; + var B = functionBind.call(A, null, 'B'); + + var result = new B(); + sst.ok(result instanceof B, 'result is instance of bound constructor'); + sst.ok(result instanceof A, 'result is instance of original constructor'); + sst.end(); + }); + + st.end(); + }); + + t.end(); +}); + +test('with a context', function (t) { + t.test('with no bound arguments', function (st) { + var args, context; + var boundContext = {}; + var namespace = { + func: functionBind.call(function () { + args = Array.prototype.slice.call(arguments); + context = this; + }, boundContext) + }; + namespace.func(1, 2, 3); + st.equal(context, boundContext, 'binds a context properly'); + st.deepEqual(args, [1, 2, 3], 'supplies passed arguments'); + st.end(); + }); + + t.test('with bound arguments', function (st) { + var args, context; + var boundContext = {}; + var namespace = { + func: functionBind.call(function () { + args = Array.prototype.slice.call(arguments); + context = this; + }, boundContext, 1, 2, 3) + }; + namespace.func(4, 5, 6); + st.equal(context, boundContext, 'binds a context properly'); + st.deepEqual(args, [1, 2, 3, 4, 5, 6], 'supplies bound and passed arguments'); + st.end(); + }); + + t.test('returns properly', function (st) { + var boundContext = {}; + var args; + var namespace = { + func: functionBind.call(function () { + args = Array.prototype.slice.call(arguments); + return this; + }, boundContext) + }; + var context = namespace.func(1, 2, 3); + st.equal(context, boundContext, 'returned context is bound context'); + st.notEqual(context, getCurrentContext.call(), 'returned context is not lexical context'); + st.deepEqual(args, [1, 2, 3], 'passed arguments are correct'); + st.end(); + }); + + t.test('returns properly with bound arguments', function (st) { + var boundContext = {}; + var args; + var namespace = { + func: functionBind.call(function () { + args = Array.prototype.slice.call(arguments); + return this; + }, boundContext, 1, 2, 3) + }; + var context = namespace.func(4, 5, 6); + st.equal(context, boundContext, 'returned context is bound context'); + st.notEqual(context, getCurrentContext.call(), 'returned context is not lexical context'); + st.deepEqual(args, [1, 2, 3, 4, 5, 6], 'passed arguments are correct'); + st.end(); + }); + + t.test('passes the correct arguments when called as a constructor', function (st) { + var expected = { name: 'Correct' }; + var namespace = { + Func: functionBind.call(function (arg) { + return arg; + }, { name: 'Incorrect' }) + }; + var returned = new namespace.Func(expected); + st.equal(returned, expected, 'returns the right arg when called as a constructor'); + st.end(); + }); + + t.test('has the new instance\'s context when called as a constructor', function (st) { + var actualContext; + var expectedContext = { foo: 'bar' }; + var namespace = { + Func: functionBind.call(function () { + actualContext = this; + }, expectedContext) + }; + var result = new namespace.Func(); + st.equal(result instanceof namespace.Func, true); + st.notEqual(actualContext, expectedContext); + st.end(); + }); + + t.end(); +}); + +test('bound function length', function (t) { + t.test('sets a correct length without thisArg', function (st) { + var subject = functionBind.call(function (a, b, c) { return a + b + c; }); + st.equal(subject.length, 3); + st.equal(subject(1, 2, 3), 6); + st.end(); + }); + + t.test('sets a correct length with thisArg', function (st) { + var subject = functionBind.call(function (a, b, c) { return a + b + c; }, {}); + st.equal(subject.length, 3); + st.equal(subject(1, 2, 3), 6); + st.end(); + }); + + t.test('sets a correct length without thisArg and first argument', function (st) { + var subject = functionBind.call(function (a, b, c) { return a + b + c; }, undefined, 1); + st.equal(subject.length, 2); + st.equal(subject(2, 3), 6); + st.end(); + }); + + t.test('sets a correct length with thisArg and first argument', function (st) { + var subject = functionBind.call(function (a, b, c) { return a + b + c; }, {}, 1); + st.equal(subject.length, 2); + st.equal(subject(2, 3), 6); + st.end(); + }); + + t.test('sets a correct length without thisArg and too many arguments', function (st) { + var subject = functionBind.call(function (a, b, c) { return a + b + c; }, undefined, 1, 2, 3, 4); + st.equal(subject.length, 0); + st.equal(subject(), 6); + st.end(); + }); + + t.test('sets a correct length with thisArg and too many arguments', function (st) { + var subject = functionBind.call(function (a, b, c) { return a + b + c; }, {}, 1, 2, 3, 4); + st.equal(subject.length, 0); + st.equal(subject(), 6); + st.end(); + }); +}); diff --git a/tools/ui/node_modules/function.prototype.name/.editorconfig b/tools/ui/node_modules/function.prototype.name/.editorconfig new file mode 100644 index 0000000000000000000000000000000000000000..b2bccd44f96034bd21da8a118076d0fd319f8cb6 --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/.editorconfig @@ -0,0 +1,24 @@ +root = true + +[*] +indent_style = tab +indent_size = 4 +end_of_line = lf +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true +max_line_length = off + +[CHANGELOG.md] +indent_style = space +indent_size = 2 + +[README.md] +indent_style = space +indent_size = 2 + +[*.json] +max_line_length = off + +[Makefile] +max_line_length = off diff --git a/tools/ui/node_modules/function.prototype.name/.eslintrc b/tools/ui/node_modules/function.prototype.name/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..92e59ca6f08aa3d2cc87b815c73fdb2395372997 --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/.eslintrc @@ -0,0 +1,15 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "max-lines-per-function": 0, + "new-cap": [2, { + "capIsNewExceptions": [ + "HasOwnProperty", + "IsCallable", + ], + }], + }, +} diff --git a/tools/ui/node_modules/function.prototype.name/.github/FUNDING.yml b/tools/ui/node_modules/function.prototype.name/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..6a3b00c775c8d02646a5060d22d7c2d3517f0778 --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/function.prototype.name +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/function.prototype.name/.nycrc b/tools/ui/node_modules/function.prototype.name/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..bdd626ce91477abbdd489b79988baebadbd3c897 --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/function.prototype.name/CHANGELOG.md b/tools/ui/node_modules/function.prototype.name/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..7cd95e6d19e89fef85b793a59ec24d8cadbf272e --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/CHANGELOG.md @@ -0,0 +1,141 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.1.8](https://github.com/es-shims/Function.prototype.name/compare/v1.1.7...v1.1.8) - 2024-12-19 + +### Commits + +- [actions] split out node 10-20, and 20+ [`b5ea555`](https://github.com/es-shims/Function.prototype.name/commit/b5ea555b2a4db8eb531bccb4d6b2c916de9b8089) +- [Refactor] use `call-bound` directly [`f6a6c64`](https://github.com/es-shims/Function.prototype.name/commit/f6a6c640f7f209c3fc1ea65c0eb31e622e2c9399) + +## [v1.1.7](https://github.com/es-shims/Function.prototype.name/compare/v1.1.6...v1.1.7) - 2024-12-15 + +### Commits + +- [actions] split out node 10-20, and 20+ [`47155b0`](https://github.com/es-shims/Function.prototype.name/commit/47155b0bef19c37e5cf9dfff393bc14c6079959a) +- [Refactor] use `hasown` and `is-callable` directly, instead of `es-abstract` [`d5118d6`](https://github.com/es-shims/Function.prototype.name/commit/d5118d65f89f8af4d1109943955ba65f88f4aa6b) +- [Deps] update `call-bind`, `define-properties`, `es-abstract` [`cfa8b2e`](https://github.com/es-shims/Function.prototype.name/commit/cfa8b2e4fcfa437dde6436c2c34e3eb4bb646907) +- [Dev Deps] update `@es-shims/api`, `@ljharb/eslint-config`, `auto-changelog`, `npmignore`, `tape` [`2077d9a`](https://github.com/es-shims/Function.prototype.name/commit/2077d9a9039c7cbf78816188bf486560366437bc) +- [Tests] replace `aud` with `npm audit` [`219e0a4`](https://github.com/es-shims/Function.prototype.name/commit/219e0a43a3de2d96e78ec61a43ccb61be40d8da8) +- [Dev Deps] add missing peer dep [`0b16b2b`](https://github.com/es-shims/Function.prototype.name/commit/0b16b2b1013b3c92793bcf87c573eab356e00388) + +## [v1.1.6](https://github.com/es-shims/Function.prototype.name/compare/v1.1.5...v1.1.6) - 2023-08-28 + +### Commits + +- [actions] reuse common workflows [`5f6bfba`](https://github.com/es-shims/Function.prototype.name/commit/5f6bfba9d2c42fbac8f4812396bc71f79464846c) +- [meta] use `npmignore` to autogenerate an npmignore file [`28ea2f9`](https://github.com/es-shims/Function.prototype.name/commit/28ea2f9a9dd48623cba04e94c491033f1c9d1e90) +- [Fix] properly recognize `document.all` in IE 6-8 [`316d676`](https://github.com/es-shims/Function.prototype.name/commit/316d67641d54bf221ed5edfdb9e04af3b98caad8) +- [Fix] only return an own `name` [`d647609`](https://github.com/es-shims/Function.prototype.name/commit/d6476090e110733b52a922f4d0dbfdbc9478c653) +- [Tests] add browserstack browser tests [`67ae402`](https://github.com/es-shims/Function.prototype.name/commit/67ae402aabcad83df2f7d7e356d059a84fe71f44) +- [meta] better `eccheck` command [`728df4c`](https://github.com/es-shims/Function.prototype.name/commit/728df4cc81a51a131a36c0768c4adb7668ad7569) +- [meta] add `auto-changelog` [`dbb700b`](https://github.com/es-shims/Function.prototype.name/commit/dbb700b38ef4c18e0ce0670a2ffface9ffd251a0) +- [readme] fix eclint [`c98fdf1`](https://github.com/es-shims/Function.prototype.name/commit/c98fdf1bc5451de667945c41187a67022f750001) +- [readme] add tested browsers [`d41325c`](https://github.com/es-shims/Function.prototype.name/commit/d41325ceec61627f63281d0649e4e0004f3e0609) +- [actions] update rebase action to use reusable workflow [`085f340`](https://github.com/es-shims/Function.prototype.name/commit/085f3400785cd4f3fb762b73b095f5dfb795a0b3) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `@es-shims/api`, `safe-publish-latest`, `tape` [`3f071ce`](https://github.com/es-shims/Function.prototype.name/commit/3f071cef2e1feebfd7d0daea7d6392c2feada091) +- [actions] update codecov uploader [`a187b4f`](https://github.com/es-shims/Function.prototype.name/commit/a187b4fd07dbbeee12e8dc60651f122ab3f41f8d) +- [Deps] update `define-properties`, `es-abstract` [`3ca42ef`](https://github.com/es-shims/Function.prototype.name/commit/3ca42ef76d5d4016d1ea87d806dc7e4a09d9b4f8) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`8de25d2`](https://github.com/es-shims/Function.prototype.name/commit/8de25d2b9b523bd385b0bf3bb9213c11ecf8f1ba) +- [Dev Deps] update `@es-shims/api`, `@ljharb/eslint-config`, `aud`, `tape` [`8b04da7`](https://github.com/es-shims/Function.prototype.name/commit/8b04da71695a1b9cf285ee926ffeec55b543595b) +- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `tape` [`39d8538`](https://github.com/es-shims/Function.prototype.name/commit/39d853854136a749c94e10f9fb06ba73903671a6) +- [meta] reorder scripts [`054f96b`](https://github.com/es-shims/Function.prototype.name/commit/054f96b5e88e08e65c4e27bcb799c7cea2bc3462) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` [`bebee89`](https://github.com/es-shims/Function.prototype.name/commit/bebee894a7989aef6e9db0dc8b16cbd9134b629c) +- [Dev Deps] update `aud`, `tape` [`8e68159`](https://github.com/es-shims/Function.prototype.name/commit/8e681599b4fbf26e921f61fd603da0524369b72c) +- [Tests] handle Function.prototype in Opera 12.1 [`f3b8f9a`](https://github.com/es-shims/Function.prototype.name/commit/f3b8f9a40b88f6da5ad41b874c3f2acf6fb30378) +- [Deps] update `es-abstract`, `functions-have-names` [`6a59889`](https://github.com/es-shims/Function.prototype.name/commit/6a598893f013182070479a8cc52afd44e556561f) +- [Deps] update `define-properties`, `es-abstract` [`cd1c5e7`](https://github.com/es-shims/Function.prototype.name/commit/cd1c5e773c3740ec563a26e657d764aba7c35a8c) +- [Deps] update `es-abstract` [`3584585`](https://github.com/es-shims/Function.prototype.name/commit/35845851109f767e3bc84ebef989ca93e5851276) +- [Deps] update `es-abstract` [`0e2f6d9`](https://github.com/es-shims/Function.prototype.name/commit/0e2f6d99d554a8b6b7c835702c8408832f9a2684) +- [Deps] update `es-abstract` [`b11748e`](https://github.com/es-shims/Function.prototype.name/commit/b11748ebbda2d840ac625ae6627cfdb090b94434) +- [Dev Deps] update `tape` [`d787a81`](https://github.com/es-shims/Function.prototype.name/commit/d787a81a1e1ce6d00dda6272e93a43bb193b1286) +- [Deps] update `es-abstract` [`4692639`](https://github.com/es-shims/Function.prototype.name/commit/469263915b07db8342f0aad29ad7eba083bea277) +- [Dev Deps] add `in-publish` [`568e263`](https://github.com/es-shims/Function.prototype.name/commit/568e2635099de326768f40d9e0eacbd024861676) + + +1.1.5 / 2021-10-01 +================= + * [Deps] update `es-abstract` + * [meta] use `prepublishOnly` script for npm 7+ + * [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `@es-shims/api`, `aud`, `tape` + * [actions] update workflows + * [actions] use `node/install` instead of `node/run`; use `codecov` action + +1.1.4 / 2021-02-22 +================= + * [readme] remove travis badge + * [meta] remove audit-level + * [meta] gitignore coverage output + * [meta] do not publish github action workflow files + * [Deps] update `call-bind`, `es-abstract`, `functions-have-names` + * [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `has-strict-mode`, `tape` + * [Tests] increase coverage + * [actions] update workflows + +1.1.3 / 2020-11-27 +================= + * [Deps] update `es-abstract`, `functions-have-names`; use `call-bind` where applicable + * [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape`, `make-arrow-function`, `make-generator-function`; add `aud`, `make-async-function` + * [actions] add "Allow Edits" workflow + * [actions] switch Automatic Rebase workflow to `pull_request_target` event + * [Tests] migrate tests to Github Actions + * [Tests] run `nyc` on all tests + * [Tests] add `implementation` test; run `es-shim-api` in postlint; use `tape` runner + * [Tests] only audit prod deps + +1.1.2 / 2019-12-14 +================= + * [Refactor] use `es-abstract` + * [Deps] update `functions-have-names` + * [meta] add `funding` field + * [meta] fix repo capitalization + * [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `safe-publish-latest` + * [Tests] use shared travis-ci configs + * [actions] add automatic rebasing / merge commit blocking + +1.1.1 / 2019-07-24 +================= + * [Refactor] use `functions-have-names` + * [meta] clean up package.json scripts + * [meta] update links + * [meta] create FUNDING.yml + * [Deps] update `is-callable`, `define-properties` + * [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape`, `safe-publish-latest`, `covert` + * [Tests] use `eccheck` over `editorconfig-tools` + * [Tests] use `npx aud` instead of `nsp` or `npm audit` with hoops + * [Tests] up to `node` `v11.7`, `v10.15`, `v9.11`, `v8.15`, `v6.16`, `v4.9` + * [Test] remove `jscs` + +1.1.0 / 2017-12-31 +================= + * [New] add `auto` entry point + * [Deps] update `function-bind` + * [Dev Deps] update `uglify-register`, `tape`, `nsp`, `eslint`, `@ljharb/eslint-config`, `@es-shims/api` + * [Tests] up to `node` `v9.3`, `v8.9`, `v6.12`; use `nvm install-latest-npm`; pin included builds to LTS + +1.0.3 / 2017-07-21 +================= + * [Fix] be robust against function name mangling + * [Refactor] move function name detection to separate file + +1.0.2 / 2017-07-14 +================= + * [Refactor] shim: Remove unnecessary `!functionsHaveNames` check + +1.0.1 / 2017-07-11 +================= + * [Fix] in IE 9-11, we must rely on `.call` being available (#13) + * [Fix] ensure that `Function.prototype.name` does not erase the getter + * [Deps] update `is-callable` + * [Dev Deps] add `safe-publish-latest` + * [Dev Deps] update `tape`, `jscs`, `nsp`, `eslint`, `@ljharb/eslint-config`, `@es-shims/api` + * [Tests] up to `node` `v8.1`; `v7.10`, `v6.11`, `v4.8`; improve matrix; newer npm fails on older nodes + * [Tests] use `Object` to avoid function name inference in node 7 + +1.0.0 / 2016-02-27 +================= + * Initial release. diff --git a/tools/ui/node_modules/function.prototype.name/LICENSE b/tools/ui/node_modules/function.prototype.name/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..44f679ad414f6f5d5b0c510a2ce31dfe811e5d47 --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2016 Jordan Harband + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/function.prototype.name/README.md b/tools/ui/node_modules/function.prototype.name/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d1ce7ce3798541f9d7383f538ea5d012c13ad645 --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/README.md @@ -0,0 +1,55 @@ +# function.prototype.name [![Version Badge][2]][1] + +[![dependency status][5]][6] +[![dev dependency status][7]][8] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][11]][1] + +An ES2015 spec-compliant `Function.prototype.name` shim. Invoke its "shim" method to shim Function.prototype.name if it is unavailable. +*Note*: `Function#name` requires a true ES5 environment - specifically, one with ES5 getters. + +This package implements the [es-shim API](https://github.com/es-shims/api) interface. It works in an ES5-supported environment and complies with the [spec](https://www.ecma-international.org/ecma-262/6.0/#sec-get-regexp.prototype.flags). + +Most common usage: + +## Example + +```js +var functionName = require('function.prototype.name'); +var assert = require('assert'); + +assert.equal(functionName(function foo() {}), 'foo'); + +functionName.shim(); +assert.equal(function foo() {}.name, 'foo'); +``` + +## Supported engines +Automatically tested in every minor version of node. + +Manually tested in: + - Safari: v4 - v15 (4, 5, 5.1, 6.0.5, 6.2, 7.1, 8, 9.1.3, 10.1.2, 11.1.2, 12.1, 13.1.2, 14.1.2, 15.3, 15.6.1) + - Chrome: v15 - v81, v83 - v106(every integer version) + - Note: This includes Edge v80+ and Opera v15+, which matches Chrome + - Firefox: v3, v3.6, v4 - v105 (every integer version) + - Note: in v42 - v63, `Function.prototype.toString` throws on HTML element constructors, or a Proxy to a function + - Note: in v20 - v35, HTML element constructors are not callable, despite having typeof `function` + - IE: v6 - v11(every integer version + - Opera: v11.1, v11.5, v11.6, v12.0, v12.1, v12.14, v12.15, v12.16, v15+ v15+ matches Chrome + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[1]: https://npmjs.org/package/function.prototype.name +[2]: https://versionbadg.es/es-shims/Function.prototype.name.svg +[5]: https://david-dm.org/es-shims/Function.prototype.name.svg +[6]: https://david-dm.org/es-shims/Function.prototype.name +[7]: https://david-dm.org/es-shims/Function.prototype.name/dev-status.svg +[8]: https://david-dm.org/es-shims/Function.prototype.name#info=devDependencies +[11]: https://nodei.co/npm/function.prototype.name.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/function.prototype.name.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/function.prototype.name.svg +[downloads-url]: https://npm-stat.com/charts.html?package=function.prototype.name diff --git a/tools/ui/node_modules/function.prototype.name/auto.js b/tools/ui/node_modules/function.prototype.name/auto.js new file mode 100644 index 0000000000000000000000000000000000000000..8ebf606cb02ff3a8c6ef786afa37d21a19254f46 --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/auto.js @@ -0,0 +1,3 @@ +'use strict'; + +require('./shim')(); diff --git a/tools/ui/node_modules/function.prototype.name/helpers/functionsHaveNames.js b/tools/ui/node_modules/function.prototype.name/helpers/functionsHaveNames.js new file mode 100644 index 0000000000000000000000000000000000000000..0aa8532eaeb3bedd408b39ce6efb7462a577f8e6 --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/helpers/functionsHaveNames.js @@ -0,0 +1,5 @@ +'use strict'; + +module.exports = require('functions-have-names')(); + +// TODO: semver-major, remove diff --git a/tools/ui/node_modules/function.prototype.name/implementation.js b/tools/ui/node_modules/function.prototype.name/implementation.js new file mode 100644 index 0000000000000000000000000000000000000000..c44ab52bc5dc7d663aa0f34a836e507a16272d1f --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/implementation.js @@ -0,0 +1,72 @@ +'use strict'; + +var IsCallable = require('is-callable'); +var hasOwn = require('hasown'); +var functionsHaveNames = require('functions-have-names')(); +var callBound = require('call-bound'); +var $functionToString = callBound('Function.prototype.toString'); +var $stringMatch = callBound('String.prototype.match'); +var toStr = callBound('Object.prototype.toString'); + +var classRegex = /^class /; + +var isClass = function isClassConstructor(fn) { + if (IsCallable(fn)) { + return false; + } + if (typeof fn !== 'function') { + return false; + } + try { + var match = $stringMatch($functionToString(fn), classRegex); + return !!match; + } catch (e) {} + return false; +}; + +var regex = /\s*function\s+([^(\s]*)\s*/; + +var isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing + +var objectClass = '[object Object]'; +var ddaClass = '[object HTMLAllCollection]'; + +var functionProto = Function.prototype; + +var isDDA = function isDocumentDotAll() { + return false; +}; +if (typeof document === 'object') { + // Firefox 3 canonicalizes DDA to undefined when it's not accessed directly + var all = document.all; + if (toStr(all) === toStr(document.all)) { + isDDA = function isDocumentDotAll(value) { + /* globals document: false */ + // in IE 6-8, typeof document.all is "object" and it's truthy + if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) { + try { + var str = toStr(value); + // IE 6-8 uses `objectClass` + return (str === ddaClass || str === objectClass) && value('') == null; // eslint-disable-line eqeqeq + } catch (e) { /**/ } + } + return false; + }; + } +} + +module.exports = function getName() { + if (isDDA(this) || (!isClass(this) && !IsCallable(this))) { + throw new TypeError('Function.prototype.name sham getter called on non-function'); + } + if (functionsHaveNames && hasOwn(this, 'name')) { + return this.name; + } + if (this === functionProto) { + return ''; + } + var str = $functionToString(this); + var match = $stringMatch(str, regex); + var name = match && match[1]; + return name; +}; diff --git a/tools/ui/node_modules/function.prototype.name/index.js b/tools/ui/node_modules/function.prototype.name/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ee9573a889fa845f06f2cf8a6af8c763fb7f9848 --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/index.js @@ -0,0 +1,18 @@ +'use strict'; + +var define = require('define-properties'); +var callBind = require('call-bind'); + +var implementation = require('./implementation'); +var getPolyfill = require('./polyfill'); +var shim = require('./shim'); + +var bound = callBind(implementation); + +define(bound, { + getPolyfill: getPolyfill, + implementation: implementation, + shim: shim +}); + +module.exports = bound; diff --git a/tools/ui/node_modules/function.prototype.name/package.json b/tools/ui/node_modules/function.prototype.name/package.json new file mode 100644 index 0000000000000000000000000000000000000000..1b537a610fd2b5b6a86f76fe7728ff22c3544c46 --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/package.json @@ -0,0 +1,101 @@ +{ + "name": "function.prototype.name", + "version": "1.1.8", + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "description": "An ES2015 spec-compliant `Function.prototype.name` shim", + "license": "MIT", + "main": "index.js", + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepublishOnly": "safe-publish-latest", + "pretest": "npm run lint", + "test": "npm run --silent tests-only", + "posttest": "npx npm@'>=10.2' audit --production", + "tests-only": "nyc tape 'test/**/*.js'", + "prelint": "eclint check $(git ls-files | xargs find 2> /dev/null | grep -vE 'node_modules|\\.git')", + "lint": "eslint --ext=js,mjs .", + "postlint": "es-shim-api --bound", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git://github.com/es-shims/Function.prototype.name.git" + }, + "keywords": [ + "Function.prototype.name", + "function", + "name", + "ES6", + "ES2015", + "shim", + "polyfill", + "es-shim API" + ], + "dependencies": { + "call-bind": "^1.0.8", + "call-bound": "^1.0.3", + "define-properties": "^1.2.1", + "functions-have-names": "^1.2.3", + "hasown": "^2.0.2", + "is-callable": "^1.2.7" + }, + "devDependencies": { + "@es-shims/api": "^2.5.1", + "@ljharb/eslint-config": "^21.1.1", + "auto-changelog": "^2.5.0", + "eclint": "^2.8.1", + "encoding": "^0.1.13", + "eslint": "=8.8.0", + "for-each": "^0.3.3", + "has-strict-mode": "^1.0.1", + "in-publish": "^2.0.1", + "make-arrow-function": "^1.2.0", + "make-async-function": "^1.0.0", + "make-generator-function": "^2.0.0", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0", + "uglify-register": "^1.0.1" + }, + "testling": { + "files": "test/index.js", + "browsers": [ + "iexplore/9.0..latest", + "firefox/4.0..6.0", + "firefox/15.0..latest", + "firefox/nightly", + "chrome/4.0..10.0", + "chrome/20.0..latest", + "chrome/canary", + "opera/11.6..latest", + "opera/next", + "safari/5.0..latest", + "ipad/6.0..latest", + "iphone/6.0..latest", + "android-browser/4.2" + ] + }, + "engines": { + "node": ">= 0.4" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true, + "startingVersion": "v1.1.6" + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + } +} diff --git a/tools/ui/node_modules/function.prototype.name/polyfill.js b/tools/ui/node_modules/function.prototype.name/polyfill.js new file mode 100644 index 0000000000000000000000000000000000000000..382fb9b6a45f316dedaef6d020645616b6becded --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/polyfill.js @@ -0,0 +1,7 @@ +'use strict'; + +var implementation = require('./implementation'); + +module.exports = function getPolyfill() { + return implementation; +}; diff --git a/tools/ui/node_modules/function.prototype.name/shim.js b/tools/ui/node_modules/function.prototype.name/shim.js new file mode 100644 index 0000000000000000000000000000000000000000..587e3e94ccc8284ffc1da6edf7748f31d9218b7e --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/shim.js @@ -0,0 +1,35 @@ +'use strict'; + +var supportsDescriptors = require('define-properties').supportsDescriptors; +var functionsHaveNames = require('functions-have-names')(); +var getPolyfill = require('./polyfill'); +var defineProperty = Object.defineProperty; +var TypeErr = TypeError; + +module.exports = function shimName() { + var polyfill = getPolyfill(); + if (functionsHaveNames) { + return polyfill; + } + if (!supportsDescriptors) { + throw new TypeErr('Shimming Function.prototype.name support requires ES5 property descriptor support.'); + } + var functionProto = Function.prototype; + defineProperty(functionProto, 'name', { + configurable: true, + enumerable: false, + get: function () { + var name = polyfill.call(this); + if (this !== functionProto) { + defineProperty(this, 'name', { + configurable: true, + enumerable: false, + value: name, + writable: false + }); + } + return name; + } + }); + return polyfill; +}; diff --git a/tools/ui/node_modules/function.prototype.name/test/implementation.js b/tools/ui/node_modules/function.prototype.name/test/implementation.js new file mode 100644 index 0000000000000000000000000000000000000000..7fdf95b7da1a541ef76ccf4f576a323b2c97097b --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/test/implementation.js @@ -0,0 +1,20 @@ +'use strict'; + +var implementation = require('../implementation'); +var callBind = require('call-bind'); +var test = require('tape'); +var hasStrictMode = require('has-strict-mode')(); +var runTests = require('./tests'); + +test('as a function', function (t) { + t.test('bad array/this value', { skip: !hasStrictMode }, function (st) { + /* eslint no-useless-call: 0 */ + st['throws'](function () { implementation.call(undefined); }, TypeError, 'undefined is not an object'); + st['throws'](function () { implementation.call(null); }, TypeError, 'null is not an object'); + st.end(); + }); + + runTests(callBind(implementation), t); + + t.end(); +}); diff --git a/tools/ui/node_modules/function.prototype.name/test/index.js b/tools/ui/node_modules/function.prototype.name/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..68e33af686db38674f7a30d86f991e6436c42cfa --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/test/index.js @@ -0,0 +1,23 @@ +'use strict'; + +var getName = require('../'); +var test = require('tape'); +var runTests = require('./tests'); + +test('as a function', function (t) { + t.test('non-functions', function (st) { + st['throws'](function () { getName(); }, TypeError, 'undefined is not a function'); + st['throws'](function () { getName(null); }, TypeError, 'null is not a function'); + st['throws'](function () { getName(true); }, TypeError, 'true is not a function'); + st['throws'](function () { getName(false); }, TypeError, 'false is not a function'); + st['throws'](function () { getName('foo'); }, TypeError, '"foo" is not a function'); + st['throws'](function () { getName([]); }, TypeError, '[] is not a function'); + st['throws'](function () { getName({}); }, TypeError, '{} is not a function'); + st['throws'](function () { getName(/a/g); }, TypeError, '/a/g is not a function'); + st.end(); + }); + + runTests(getName, t); + + t.end(); +}); diff --git a/tools/ui/node_modules/function.prototype.name/test/shimmed.js b/tools/ui/node_modules/function.prototype.name/test/shimmed.js new file mode 100644 index 0000000000000000000000000000000000000000..c2ed13a3df2ff04a5640192abf006bf6450bfcee --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/test/shimmed.js @@ -0,0 +1,21 @@ +'use strict'; + +require('../auto'); + +var test = require('tape'); +var supportsDescriptors = require('define-properties').supportsDescriptors; +var isEnumerable = Object.prototype.propertyIsEnumerable; + +var runTests = require('./tests'); + +test('shimmed', function (t) { + t.test('enumerability', { skip: !supportsDescriptors }, function (et) { + et.equal(false, isEnumerable.call(Function.prototype, 'name'), 'Function#name is not enumerable'); + et.equal(false, isEnumerable.call(function foo() {}, 'name'), 'a function’s name is not enumerable'); + et.end(); + }); + + runTests(function (fn) { return fn.name; }, t); + + t.end(); +}); diff --git a/tools/ui/node_modules/function.prototype.name/test/tests.js b/tools/ui/node_modules/function.prototype.name/test/tests.js new file mode 100644 index 0000000000000000000000000000000000000000..4b6362ede681d86ad7f4401b7cdeb40e9a47697e --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/test/tests.js @@ -0,0 +1,104 @@ +'use strict'; + +var functionsHaveNames = require('functions-have-names')(); +var arrows = require('make-arrow-function').list(); +var generators = require('make-generator-function')(); +var asyncs = require('make-async-function').list(); +var IsCallable = require('is-callable'); +var forEach = require('for-each'); + +var foo = Object(function foo() {}); +var anon = Object(function () {}); +var evalled = Object(Function()); // eslint-disable-line no-new-func + +module.exports = function (getName, t) { + t.test('functions', function (st) { + if (functionsHaveNames) { + st.equal(getName(foo), foo.name, 'foo has name "foo"'); + st.equal(getName(anon), anon.name, 'anonymous function has name of empty string'); + st.equal(getName(evalled), evalled.name, 'eval-d function has name "anonymous" (or empty string)'); + } + st.equal(getName(foo), 'foo', 'foo has name "foo"'); + st.equal(getName(anon), '', 'anonymous function has name of empty string'); + var evalledName = getName(evalled); + st.equal(evalledName === 'anonymous' || evalledName === '', true, 'eval-d function has name "anonymous" (or empty string'); + st.end(); + }); + + t.test('arrow functions', { skip: arrows.length === 0 }, function (st) { + st.equal(true, functionsHaveNames, 'functions have names in any env with arrow functions'); + forEach(arrows, function (arrowFn) { + st.equal(getName(arrowFn), arrowFn.name, 'arrow function name matches for ' + arrowFn); + }); + st.end(); + }); + + t.test('generators', { skip: generators.length === 0 }, function (st) { + st.equal(true, functionsHaveNames, 'functions have names in any env with generator functions'); + forEach(generators, function (genFn) { + st.equal(getName(genFn), genFn.name, 'generator function name matches for ' + genFn); + }); + st.end(); + }); + + t.test('asyncs', { skip: asyncs.length === 0 }, function (st) { + st.equal(true, functionsHaveNames, 'functions have names in any env with async functions'); + forEach(asyncs, function (asyncFn) { + st.equal(getName(asyncFn), asyncFn.name, 'async function name matches for ' + asyncFn); + }); + st.end(); + }); + + t.test('Function.prototype.name', function (st) { + st.equal(getName(function before() {}), 'before', 'function prior to accessing Function.prototype has the right name'); + var protoName = getName(Function.prototype); + // on <= node v2.5, this is "Empty"; on Opera 12.1, "Function.prototype" - otherwise, the empty string + st.equal(protoName === '' || protoName === 'Empty' || protoName === 'Function.prototype', true, 'Function.prototype has the right name'); + st.equal(getName(function after() {}), 'after', 'function after accessing Function.prototype has the right name'); + + st.end(); + }); + + t.test('DOM', function (st) { + /* eslint-env browser */ + + st.test('document.all', { skip: typeof document !== 'object' }, function (s2t) { + s2t['throws']( + function () { getName(document.all); }, + TypeError, + 'a document.all has no name' + ); + + s2t.end(); + }); + + forEach([ + 'HTMLElement', + 'HTMLAnchorElement' + ], function (name) { + var constructor = global[name]; + + st.test(name, { skip: !constructor }, function (s2t) { + s2t.match(typeof constructor, /^(?:function|object)$/, name + ' is a function or an object'); + + if (IsCallable(constructor)) { + try { + s2t.equal(getName(constructor), name, name + ' has the right name'); + } catch (e) { + s2t.fail(e); + } + } else { + s2t['throws']( + function () { getName(constructor); }, + TypeError, + name + ' is not callable' + ); + } + + s2t.end(); + }); + }); + + st.end(); + }); +}; diff --git a/tools/ui/node_modules/function.prototype.name/test/uglified.js b/tools/ui/node_modules/function.prototype.name/test/uglified.js new file mode 100644 index 0000000000000000000000000000000000000000..77733abd85d034121f65b477a02b39647c62b479 --- /dev/null +++ b/tools/ui/node_modules/function.prototype.name/test/uglified.js @@ -0,0 +1,17 @@ +'use strict'; + +var test = require('tape'); +var runTests = require('./tests'); + +test('with uglify', function (t) { + /* eslint global-require: 0 */ + require('uglify-register/api').register({ + exclude: [/\/node_modules\//, /\/test\//], + uglify: { mangle: true } + }); + + var getName = require('../'); + runTests(getName, t); + + t.end(); +}); diff --git a/tools/ui/node_modules/functions-have-names/.editorconfig b/tools/ui/node_modules/functions-have-names/.editorconfig new file mode 100644 index 0000000000000000000000000000000000000000..bc228f8269443bf772b437890dde7756a3e8a894 --- /dev/null +++ b/tools/ui/node_modules/functions-have-names/.editorconfig @@ -0,0 +1,20 @@ +root = true + +[*] +indent_style = tab +indent_size = 4 +end_of_line = lf +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true +max_line_length = 150 + +[CHANGELOG.md] +indent_style = space +indent_size = 2 + +[*.json] +max_line_length = off + +[Makefile] +max_line_length = off diff --git a/tools/ui/node_modules/functions-have-names/.eslintrc b/tools/ui/node_modules/functions-have-names/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..2807df70cb18de3075f1e15022b5bd38c8ff175e --- /dev/null +++ b/tools/ui/node_modules/functions-have-names/.eslintrc @@ -0,0 +1,19 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "func-name-matching": [2, "always"], + "id-length": 1, + }, + + "overrides": [ + { + "files": "test/**", + "rules": { + "func-name-matching": 0, + }, + }, + ], +} diff --git a/tools/ui/node_modules/functions-have-names/.github/FUNDING.yml b/tools/ui/node_modules/functions-have-names/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..1b81d18bc0ae25b735729ca3f5cbbb3ed23a574a --- /dev/null +++ b/tools/ui/node_modules/functions-have-names/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/functions-have-names +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/functions-have-names/.nycrc b/tools/ui/node_modules/functions-have-names/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..bdd626ce91477abbdd489b79988baebadbd3c897 --- /dev/null +++ b/tools/ui/node_modules/functions-have-names/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/functions-have-names/CHANGELOG.md b/tools/ui/node_modules/functions-have-names/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..1026b701d7865bc75a2869f9d543ccd926792712 --- /dev/null +++ b/tools/ui/node_modules/functions-have-names/CHANGELOG.md @@ -0,0 +1,89 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.2.3](https://github.com/inspect-js/functions-have-names/compare/v1.2.2...v1.2.3) - 2022-04-19 + +### Fixed + +- [Fix] in IE 9-11, the descriptor is absent [`#11`](https://github.com/inspect-js/functions-have-names/issues/11) [`#25`](https://github.com/es-shims/RegExp.prototype.flags/issues/25) + +### Commits + +- [actions] reuse common workflows [`4ed274a`](https://github.com/inspect-js/functions-have-names/commit/4ed274a2441c7fd38ff6add741c309e268550d97) +- [actions] use `node/install` instead of `node/run`; use `codecov` action [`96dfcaa`](https://github.com/inspect-js/functions-have-names/commit/96dfcaaf1c9c5305f2b66ef69f9cddf1d9d9a578) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `tape` [`9e674f8`](https://github.com/inspect-js/functions-have-names/commit/9e674f85520a93235e412a3fd7671d2356c6e45b) +- [readme] add github actions/codecov badges; update URLs [`d913f5b`](https://github.com/inspect-js/functions-have-names/commit/d913f5bf38ccab32d5fbea4a044b9cd93a4b9bec) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `safe-publish-latest`, `tape` [`f61058f`](https://github.com/inspect-js/functions-have-names/commit/f61058fe1e34f2cfa9235283a4fc6c0c0172c91a) +- [actions] update codecov uploader [`3348839`](https://github.com/inspect-js/functions-have-names/commit/33488394e7cadbf499bee4775c627c1370d033d0) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `safe-publish-latest`, `tape` [`ee1a321`](https://github.com/inspect-js/functions-have-names/commit/ee1a3211a40902af59aa629e3ac41ec36360dc1b) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` [`b8dc1a2`](https://github.com/inspect-js/functions-have-names/commit/b8dc1a277b08362bebedfeba2faca8964f68283b) +- [Dev Deps] update `@ljharb/eslint-config`, `tape` [`0e825c4`](https://github.com/inspect-js/functions-have-names/commit/0e825c4ba8525b02d9acaaf2511371f76c0562ce) +- [meta] use `prepublishOnly` script for npm 7+ [`9489d66`](https://github.com/inspect-js/functions-have-names/commit/9489d666c59702ea6bafd3ff611b3eadfee6570e) + +## [v1.2.2](https://github.com/inspect-js/functions-have-names/compare/v1.2.1...v1.2.2) - 2020-12-14 + +### Commits + +- [Tests] migrate tests to Github Actions [`39bf4fe`](https://github.com/inspect-js/functions-have-names/commit/39bf4fe5ae5b3610a80ba13726f3ee00e3c49e2f) +- [meta] do not publish github action workflow files [`45ab0cb`](https://github.com/inspect-js/functions-have-names/commit/45ab0cbdc0da2efd64f5deb9810be63009bac4a0) +- [readme] add docs, fix URLs [`fad3af6`](https://github.com/inspect-js/functions-have-names/commit/fad3af61e9cbc27f47d2097614f43c62ae1022dd) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `tape` [`82df94a`](https://github.com/inspect-js/functions-have-names/commit/82df94ae06f05a5fa321dda9b7d902ac9fc26424) +- [Tests] run `nyc` on all tests; use `tape` runner [`8038329`](https://github.com/inspect-js/functions-have-names/commit/8038329fec493043639d9d8c779141dcb7d00c2d) +- [actions] add automatic rebasing / merge commit blocking [`49795eb`](https://github.com/inspect-js/functions-have-names/commit/49795ebf38ae3ba724ff7ac5c53598ec66ab814b) +- [actions] add "Allow Edits" workflow [`2096fe6`](https://github.com/inspect-js/functions-have-names/commit/2096fe6d67d435c0e0da25f3cfe9ff02991c41e6) +- [actions] switch Automatic Rebase workflow to `pull_request_target` event [`ec1c6fe`](https://github.com/inspect-js/functions-have-names/commit/ec1c6fe209419c722d732cd512e4375c48366392) +- [Dev Deps] update `auto-changelog`; add `aud` [`79fdb23`](https://github.com/inspect-js/functions-have-names/commit/79fdb23d1ed2b4125f443be193c37330e634e654) +- [Tests] only audit prod deps [`d9ca245`](https://github.com/inspect-js/functions-have-names/commit/d9ca2455e26a45994024d1027344c268a06818bd) +- [Dev Deps] update `auto-changelog`, `tape` [`ac026d4`](https://github.com/inspect-js/functions-have-names/commit/ac026d4bda77e9820b74456fc752d2069e5b8a7f) +- [Dev Deps] update `tape` [`a8c5ee3`](https://github.com/inspect-js/functions-have-names/commit/a8c5ee3622b487938462f82698dae3ceb32da1a7) +- [Dev Deps] update `@ljharb/eslint-config` [`b25fafd`](https://github.com/inspect-js/functions-have-names/commit/b25fafd0923dcf53c3aeca92268e497ffd96ec34) + +## [v1.2.1](https://github.com/inspect-js/functions-have-names/compare/v1.2.0...v1.2.1) - 2020-01-19 + +### Commits + +- [Tests] use shared travis-ci configs [`612823a`](https://github.com/inspect-js/functions-have-names/commit/612823a064b4be4c61a1e52d1009abed4a4fc4fb) +- [Fix] IE 8 has a broken `Object.getOwnPropertyDescriptor` [`ba01c22`](https://github.com/inspect-js/functions-have-names/commit/ba01c22795162b787a698950ea34250ce68a7bb1) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `auto-changelog`; add `safe-publish-latest` [`b28d9d2`](https://github.com/inspect-js/functions-have-names/commit/b28d9d2e8bc0b758671bcaf2f7aa0d4ad4b42046) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` [`a62fbd6`](https://github.com/inspect-js/functions-have-names/commit/a62fbd69a34a2b1d1860acfa2afc6dcc839bc180) +- [meta] add `funding` field [`8734a94`](https://github.com/inspect-js/functions-have-names/commit/8734a940e39acdf7619eb89e358746bd278b4c90) + +## [v1.2.0](https://github.com/inspect-js/functions-have-names/compare/v1.1.1...v1.2.0) - 2019-10-20 + +### Commits + +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `auto-changelog` [`7e07444`](https://github.com/inspect-js/functions-have-names/commit/7e0744437789641ea462005d2e350ef476aa7141) +- [New] add `boundFunctionsHaveNames()` [`05661be`](https://github.com/inspect-js/functions-have-names/commit/05661be26c3c260bb3984e433dc9cea3fd82f9ac) + +## [v1.1.1](https://github.com/inspect-js/functions-have-names/compare/v1.1.0...v1.1.1) - 2019-07-24 + +### Commits + +- [Tests] fix linting errors [`0cb8017`](https://github.com/inspect-js/functions-have-names/commit/0cb8017203ae37d1e019bb1c99120f3f56a266a5) +- [Tests] fix tests when name is not configurable [`38a8aee`](https://github.com/inspect-js/functions-have-names/commit/38a8aeee0403bd7aa7f35da76dc433cbcdd3f85a) +- [Fix] ensure function name mangling does not break detection [`f6926ab`](https://github.com/inspect-js/functions-have-names/commit/f6926abaaebc81366f73cf0c3f874ad7e4ba16d2) + +## [v1.1.0](https://github.com/inspect-js/functions-have-names/compare/v1.0.0...v1.1.0) - 2019-07-23 + +### Commits + +- [New] add `functionsHaveConfigurableNames` function on main export [`ce73f75`](https://github.com/inspect-js/functions-have-names/commit/ce73f75891640a462326df7266d90b09519a5fca) + +## v1.0.0 - 2019-07-22 + +### Commits + +- [Tests] add travis.yml [`06ed096`](https://github.com/inspect-js/functions-have-names/commit/06ed09681a3dc067094562e8d21a31400a782add) +- Initial commit [`ced60bd`](https://github.com/inspect-js/functions-have-names/commit/ced60bd089539eb228c68fc2ad7c7bc04b959b02) +- npm init [`79088ab`](https://github.com/inspect-js/functions-have-names/commit/79088ab607e7e91a402e198ab6d1837a317c6fa9) +- add tests [`c9e8e09`](https://github.com/inspect-js/functions-have-names/commit/c9e8e09c5153797c97c324cca4b837540eddeff8) +- [Tests] add `npm run lint` [`988b924`](https://github.com/inspect-js/functions-have-names/commit/988b924a8a49ea5c0f30d5aa2b2ea9add0b39474) +- [meta] create FUNDING.yml [`2e443ef`](https://github.com/inspect-js/functions-have-names/commit/2e443ef67748214d05898b3da76f908a7e2d7488) +- [meta] add version scripts [`52005e3`](https://github.com/inspect-js/functions-have-names/commit/52005e3794fd0799db5963a5359846798cb95c14) +- implementation [`b7b4942`](https://github.com/inspect-js/functions-have-names/commit/b7b49421ef69fb5e042194a650cb4f71bb4996e4) +- Only apps should have lockfiles [`81d2e04`](https://github.com/inspect-js/functions-have-names/commit/81d2e04e7a43cbff2e46e72781bb0693dbb67800) +- [Tests] use `npx aud` [`baa92d8`](https://github.com/inspect-js/functions-have-names/commit/baa92d8aba331fe8821663bc14baf2e11685474a) diff --git a/tools/ui/node_modules/functions-have-names/LICENSE b/tools/ui/node_modules/functions-have-names/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..3900dd7e2ffe6d5205fde1cd3f890aa51ea36234 --- /dev/null +++ b/tools/ui/node_modules/functions-have-names/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 Jordan Harband + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/functions-have-names/README.md b/tools/ui/node_modules/functions-have-names/README.md new file mode 100644 index 0000000000000000000000000000000000000000..70962607cd607096143845a1aaf636aa8a90c484 --- /dev/null +++ b/tools/ui/node_modules/functions-have-names/README.md @@ -0,0 +1,40 @@ +# functions-have-names [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +Does this JS environment support the `name` property on functions? + +## Example + +```js +var functionsHaveNames = require('functions-have-names'); +var assert = require('assert'); + +assert.equal(functionsHaveNames(), true); // will be `false` in IE 6-8 +``` + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[package-url]: https://npmjs.org/package/functions-have-names +[npm-version-svg]: https://versionbadg.es/inspect-js/functions-have-names.svg +[deps-svg]: https://david-dm.org/inspect-js/functions-have-names.svg +[deps-url]: https://david-dm.org/inspect-js/functions-have-names +[dev-deps-svg]: https://david-dm.org/inspect-js/functions-have-names/dev-status.svg +[dev-deps-url]: https://david-dm.org/inspect-js/functions-have-names#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/functions-have-names.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/functions-have-names.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/functions-have-names.svg +[downloads-url]: https://npm-stat.com/charts.html?package=functions-have-names +[codecov-image]: https://codecov.io/gh/inspect-js/functions-have-names/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/inspect-js/functions-have-names/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/functions-have-names +[actions-url]: https://github.com/inspect-js/functions-have-names/actions diff --git a/tools/ui/node_modules/functions-have-names/index.js b/tools/ui/node_modules/functions-have-names/index.js new file mode 100644 index 0000000000000000000000000000000000000000..9d699dc190ed16b7ee94ca532fa4805eb602505e --- /dev/null +++ b/tools/ui/node_modules/functions-have-names/index.js @@ -0,0 +1,31 @@ +'use strict'; + +var functionsHaveNames = function functionsHaveNames() { + return typeof function f() {}.name === 'string'; +}; + +var gOPD = Object.getOwnPropertyDescriptor; +if (gOPD) { + try { + gOPD([], 'length'); + } catch (e) { + // IE 8 has a broken gOPD + gOPD = null; + } +} + +functionsHaveNames.functionsHaveConfigurableNames = function functionsHaveConfigurableNames() { + if (!functionsHaveNames() || !gOPD) { + return false; + } + var desc = gOPD(function () {}, 'name'); + return !!desc && !!desc.configurable; +}; + +var $bind = Function.prototype.bind; + +functionsHaveNames.boundFunctionsHaveNames = function boundFunctionsHaveNames() { + return functionsHaveNames() && typeof $bind === 'function' && function f() {}.bind().name !== ''; +}; + +module.exports = functionsHaveNames; diff --git a/tools/ui/node_modules/functions-have-names/package.json b/tools/ui/node_modules/functions-have-names/package.json new file mode 100644 index 0000000000000000000000000000000000000000..3a513cb3e6cc0535500ed9ee2f281a4b552b7854 --- /dev/null +++ b/tools/ui/node_modules/functions-have-names/package.json @@ -0,0 +1,55 @@ +{ + "name": "functions-have-names", + "version": "1.2.3", + "description": "Does this JS environment support the `name` property on functions?", + "main": "index.js", + "scripts": { + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepublishOnly": "safe-publish-latest", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"", + "lint": "eslint --ext=js,mjs .", + "pretest": "npm run lint", + "tests-only": "nyc tape 'test/**/*.js'", + "test": "npm run tests-only", + "posttest": "aud --production" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/inspect-js/functions-have-names.git" + }, + "keywords": [ + "function", + "name", + "es5", + "names", + "functions", + "ie" + ], + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/inspect-js/functions-have-names/issues" + }, + "homepage": "https://github.com/inspect-js/functions-have-names#readme", + "devDependencies": { + "@ljharb/eslint-config": "^21.0.0", + "aud": "^2.0.0", + "auto-changelog": "^2.4.0", + "eslint": "=8.8.0", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "tape": "^5.5.3" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + } +} diff --git a/tools/ui/node_modules/functions-have-names/test/index.js b/tools/ui/node_modules/functions-have-names/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..0d451ce62b6ed51787a3ae7048f91b9f46b13ec7 --- /dev/null +++ b/tools/ui/node_modules/functions-have-names/test/index.js @@ -0,0 +1,65 @@ +'use strict'; + +var test = require('tape'); + +var hasNames = require('../'); + +test('named functions', function (t) { + function f() {} // eslint-disable-line func-style + var g = function h() {}; + + t.equal(typeof hasNames, 'function', 'is a function'); + t.equal(hasNames(), f.name === 'f' && g.name === 'h', 'functions have names or not as expected'); + + t.end(); +}); + +var oDP = Object.defineProperty; +if (oDP) { + try { + oDP({}, 'a', { value: 1 }); + } catch (e) { + oDP = null; + } +} + +test('functionsHaveConfigurableNames', function (t) { + t.equal(typeof hasNames.functionsHaveConfigurableNames, 'function', 'is a function'); + + if (hasNames()) { + var fn = function f() {}; + if (oDP) { + try { + oDP(fn, 'name', { configurable: true, value: 'foo' }); + } catch (e) {} + if (fn.name === 'f') { + t.equal(hasNames.functionsHaveConfigurableNames(), false, 'function names are not configurable'); + } else if (fn.name === 'foo') { + t.equal(hasNames.functionsHaveConfigurableNames(), true, 'function names are not configurable'); + } else { + t.fail('functions have names, but something surprising has happened. Please report this!'); + } + } else { + t.equal(hasNames.functionsHaveConfigurableNames(), false, 'function names are not configurable'); + } + } else { + t.equal(hasNames.functionsHaveConfigurableNames(), false, 'functions do not have names'); + } + + t.end(); +}); + +test('boundFunctionsHaveNames', function (t) { + t.equal(typeof hasNames.boundFunctionsHaveNames, 'function', 'is a function'); + + var fn = function f() {}; + if (typeof fn.bind !== 'function') { + t.equal(hasNames.boundFunctionsHaveNames(), false, 'bound functions do not have names, because .bind does not exist'); + } else if (hasNames()) { + t.equal(hasNames.boundFunctionsHaveNames(), fn.bind().name !== '', 'bound functions have names'); + } else { + t.equal(hasNames.boundFunctionsHaveNames(), false, 'bound functions do not have names, because none do'); + } + + t.end(); +}); diff --git a/tools/ui/node_modules/generator-function/.eslintrc b/tools/ui/node_modules/generator-function/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..2e3c83be9c859621498dba15dd26ae073c42b6b6 --- /dev/null +++ b/tools/ui/node_modules/generator-function/.eslintrc @@ -0,0 +1,16 @@ +{ + "root": true, + + "extends": "@ljharb", + + "overrides": [ + { + "files": "./index.js", + "extends": "@ljharb/eslint-config/node/8" + }, + { + "files": "./require.mjs", + "extends": "@ljharb/eslint-config/node/16", + }, + ], +} diff --git a/tools/ui/node_modules/generator-function/.github/FUNDING.yml b/tools/ui/node_modules/generator-function/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..9561cd63c84d2a7356c9ac1f798129c9ca8962aa --- /dev/null +++ b/tools/ui/node_modules/generator-function/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/generator-function +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/generator-function/.nycrc b/tools/ui/node_modules/generator-function/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..bdd626ce91477abbdd489b79988baebadbd3c897 --- /dev/null +++ b/tools/ui/node_modules/generator-function/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/generator-function/CHANGELOG.md b/tools/ui/node_modules/generator-function/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..89e7e74469502dfdde5503398b14434c78c18930 --- /dev/null +++ b/tools/ui/node_modules/generator-function/CHANGELOG.md @@ -0,0 +1,27 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v2.0.1](https://github.com/TimothyGu/generator-function/compare/v2.0.0...v2.0.1) - 2025-09-30 + +### Commits + +- [meta] fix repo URL [`f5d05f2`](https://github.com/TimothyGu/generator-function/commit/f5d05f278e1f0660c418bf0b867e0013873da48c) + +## [v2.0.0](https://github.com/TimothyGu/generator-function/compare/v1.0.0...v2.0.0) - 2025-09-29 + +### Commits + +- Initial reimplementation, tests, readme, types [`e5940de`](https://github.com/TimothyGu/generator-function/commit/e5940de4328fc70ad27aa4bab4245f6c9ce62a44) +- [meta] remove unused files [`460bbe9`](https://github.com/TimothyGu/generator-function/commit/460bbe9cc6c89f9fdab05a001dc924308124613b) +- [Dev Deps] add missing peer dep [`b873c0d`](https://github.com/TimothyGu/generator-function/commit/b873c0dad8f38b08e2acc4bd5204a90dde0fe051) +- [meta] fix FUNDING.yml [`9ae9d43`](https://github.com/TimothyGu/generator-function/commit/9ae9d432a0c06d698e1aeb20b1161ca8a08b3cbb) + +## v1.0.0 - 2015-10-10 + +### Commits + +- Initial commit [`176e0cd`](https://github.com/TimothyGu/generator-function/commit/176e0cd3a5ebb004aa666c6eecbe5a968efbddf9) diff --git a/tools/ui/node_modules/generator-function/LICENSE.md b/tools/ui/node_modules/generator-function/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..41403d2fa1b4b73915c4328c39bee67a5d39fae8 --- /dev/null +++ b/tools/ui/node_modules/generator-function/LICENSE.md @@ -0,0 +1,7 @@ +Copyright (c) 2015 Tiancheng “Timothy” Gu + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/generator-function/README.md b/tools/ui/node_modules/generator-function/README.md new file mode 100644 index 0000000000000000000000000000000000000000..42060c74428702db39e6e28ba5dc06bdaeb5f879 --- /dev/null +++ b/tools/ui/node_modules/generator-function/README.md @@ -0,0 +1,51 @@ +# generator-function [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +A function that returns the normally hidden `GeneratorFunction` constructor, when available. + +## Getting started + +```sh +npm install --save generator-function +``` + +## Usage/Examples + +```js +const assert = require('assert'); +const GeneratorFunction = require('generator-function')(); + +const fn = new GeneratorFunction('return 1'); + +assert.equal(fn.toString(), 'function* anonymous(\n) {\nreturn 1\n}'); + +const iterator = fn(); + +assert.deepEqual(iterator.next(), { done: true, value: 1 }); +``` + +## Tests + +Clone the repo, `npm install`, and run `npm test` + +[package-url]: https://npmjs.org/package/generator-function +[npm-version-svg]: https://versionbadg.es/TimothyGu/generator-function.svg +[deps-svg]: https://david-dm.org/TimothyGu/generator-function.svg +[deps-url]: https://david-dm.org/TimothyGu/generator-function +[dev-deps-svg]: https://david-dm.org/TimothyGu/generator-function/dev-status.svg +[dev-deps-url]: https://david-dm.org/TimothyGu/generator-function#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/generator-function.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/generator-function.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/generator-function.svg +[downloads-url]: https://npm-stat.com/charts.html?package=generator-function +[codecov-image]: https://codecov.io/gh/TimothyGu/generator-function/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/TimothyGu/generator-function/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/TimothyGu/generator-function +[actions-url]: https://github.com/TimothyGu/generator-function/actions diff --git a/tools/ui/node_modules/generator-function/index.d.mts b/tools/ui/node_modules/generator-function/index.d.mts new file mode 100644 index 0000000000000000000000000000000000000000..76b1b8cb4f45b4889923c1d59c4362d049a9a259 --- /dev/null +++ b/tools/ui/node_modules/generator-function/index.d.mts @@ -0,0 +1,3 @@ +import type getGeneratorFunction = require('./index.d.ts'); + +export default getGeneratorFunction; \ No newline at end of file diff --git a/tools/ui/node_modules/generator-function/index.d.ts b/tools/ui/node_modules/generator-function/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..4f4e34adb54cf07b6ba584f96557f50881cbe3ee --- /dev/null +++ b/tools/ui/node_modules/generator-function/index.d.ts @@ -0,0 +1,3 @@ +declare function getGeneratorFunction(): GeneratorFunctionConstructor | false; + +export = getGeneratorFunction; \ No newline at end of file diff --git a/tools/ui/node_modules/generator-function/index.js b/tools/ui/node_modules/generator-function/index.js new file mode 100644 index 0000000000000000000000000000000000000000..b2e152c46c7889d39312472d2f742978879ba7f9 --- /dev/null +++ b/tools/ui/node_modules/generator-function/index.js @@ -0,0 +1,8 @@ +'use strict'; + +// eslint-disable-next-line no-extra-parens, no-empty-function +const cached = /** @type {GeneratorFunctionConstructor} */ (function* () {}.constructor); + +/** @type {import('.')} */ +module.exports = () => cached; + diff --git a/tools/ui/node_modules/generator-function/index.mjs b/tools/ui/node_modules/generator-function/index.mjs new file mode 100644 index 0000000000000000000000000000000000000000..b4c0488919040a437ac8a8e503a5b99334f75df9 --- /dev/null +++ b/tools/ui/node_modules/generator-function/index.mjs @@ -0,0 +1,4 @@ +import getGeneratorFunction from './index.js'; + +/** @type {import('./index.d.mts').default} */ +export default getGeneratorFunction; diff --git a/tools/ui/node_modules/generator-function/legacy.js b/tools/ui/node_modules/generator-function/legacy.js new file mode 100644 index 0000000000000000000000000000000000000000..99a09789c047c95cdd7838ea7603a3ad702117f7 --- /dev/null +++ b/tools/ui/node_modules/generator-function/legacy.js @@ -0,0 +1,18 @@ +'use strict'; + +/** @type {GeneratorFunctionConstructor | false} */ +var cached; + +/** @type {import('./index.js')} */ +module.exports = function getGeneratorFunction() { + if (typeof cached === 'undefined') { + try { + // eslint-disable-next-line no-new-func + cached = Function('return function* () {}')().constructor; + } catch (e) { + cached = false; + } + } + return cached; +}; + diff --git a/tools/ui/node_modules/generator-function/package.json b/tools/ui/node_modules/generator-function/package.json new file mode 100644 index 0000000000000000000000000000000000000000..73896ebc049ce9ed29f4cf2ceac3fc34099ffa4b --- /dev/null +++ b/tools/ui/node_modules/generator-function/package.json @@ -0,0 +1,88 @@ +{ + "name": "generator-function", + "version": "2.0.1", + "description": "A function that returns the normally hidden `GeneratorFunction` constructor", + "main": "./legacy.js", + "jsnext:main": "./index.mjs", + "module": "./index.mjs", + "exports": { + ".": [ + { + "module-sync": "./require.mjs", + "import": "./index.mjs", + "default": "./index.js" + }, + "./index.js" + ], + "./package.json": "./package.json" + }, + "sideEffects": false, + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepublishOnly": "safe-publish-latest", + "pretest": "npm run --silent lint", + "test": "npm run tests-only", + "posttest": "npx npm@\">=10.2\" audit --production", + "tests-only": "nyc tape 'test/**/*.js'", + "prelint": "evalmd README.md", + "lint": "eslint --ext=js,mjs .", + "postlint": "tsc && attw -P", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/TimothyGu/generator-function.git" + }, + "keywords": [ + "generator", + "function", + "native" + ], + "author": "Jordan Harbamd ", + "license": "MIT", + "bugs": { + "url": "https://github.com/TimothyGu/generator-function/issues" + }, + "homepage": "https://github.com/TimothyGu/generator-function#readme", + "devDependencies": { + "@arethetypeswrong/cli": "^0.18.2", + "@ljharb/eslint-config": "^21.2.0", + "@ljharb/tsconfig": "^0.3.2", + "@types/semver": "^6.2.7", + "@types/tape": "^5.8.1", + "auto-changelog": "^2.5.0", + "encoding": "^0.1.13", + "eslint": "=8.8.0", + "evalmd": "^0.0.19", + "generator-function": "file:.", + "get-proto": "^1.0.1", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "semver": "^6.3.1", + "tape": "^5.9.0", + "typescript": "next" + }, + "engines": { + "node": ">= 0.4" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + }, + "testling": { + "files": "test/index.js" + } +} diff --git a/tools/ui/node_modules/generator-function/require.mjs b/tools/ui/node_modules/generator-function/require.mjs new file mode 100644 index 0000000000000000000000000000000000000000..d03b2f789f82a6cacac27d84742d3ce6b3a6c7af --- /dev/null +++ b/tools/ui/node_modules/generator-function/require.mjs @@ -0,0 +1,5 @@ +import getGeneratorFunction from './index.js'; + +export default getGeneratorFunction; + +export { getGeneratorFunction as 'module.exports' }; diff --git a/tools/ui/node_modules/generator-function/test/index.js b/tools/ui/node_modules/generator-function/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..617024c7992470a8843540c27b3a3eafb1522856 --- /dev/null +++ b/tools/ui/node_modules/generator-function/test/index.js @@ -0,0 +1,42 @@ +'use strict'; + +var test = require('tape'); +var getProto = require('get-proto'); +var semver = require('semver'); + +var getGeneratorFunction = require('generator-function'); + +test('getGeneratorFunction', function (t) { + var result = getGeneratorFunction(); + + /* eslint-env browser */ + if (typeof window === 'undefined' && typeof process !== 'undefined') { + t.equal( + !!result, + semver.satisfies(process.version, '>= 1'), + 'result is present or absent as expected for node ' + process.version + ); + } + + t.test('exists', { skip: !result }, function (st) { + if (result && getProto) { // TS can't infer `skip`, or that getProto definitely exists if GeneratorFunction exists + st.equal(typeof result, 'function', 'is a function'); + st.equal(getProto(result), Function, 'extends Function'); + + var iterator = result('a', 'return a')(42); + st.deepEqual(iterator.next(), { value: 42, done: true }, 'returns a generator function which returns an iterator'); + } else { + st.fail('should never get here'); + } + + st.end(); + }); + + t.test('does not exist', { skip: !!result }, function (st) { + st.equal(result, false, 'is false'); + + st.end(); + }); + + t.end(); +}); diff --git a/tools/ui/node_modules/generator-function/tsconfig.json b/tools/ui/node_modules/generator-function/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..d9a6668c3ae6be748c78fbd5694053706b3d6942 --- /dev/null +++ b/tools/ui/node_modules/generator-function/tsconfig.json @@ -0,0 +1,9 @@ +{ + "extends": "@ljharb/tsconfig", + "compilerOptions": { + "target": "es2021", + }, + "exclude": [ + "coverage", + ], +} diff --git a/tools/ui/node_modules/gensync/LICENSE b/tools/ui/node_modules/gensync/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..af7f781f59eed4c85dea6ac262d09c613dc9cb5a --- /dev/null +++ b/tools/ui/node_modules/gensync/LICENSE @@ -0,0 +1,7 @@ +Copyright 2018 Logan Smyth + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/gensync/README.md b/tools/ui/node_modules/gensync/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f68ce1a37b927d6299b913bba57e4309b56a1133 --- /dev/null +++ b/tools/ui/node_modules/gensync/README.md @@ -0,0 +1,196 @@ +# gensync + +This module allows for developers to write common code that can share +implementation details, hiding whether an underlying request happens +synchronously or asynchronously. This is in contrast with many current Node +APIs which explicitly implement the same API twice, once with calls to +synchronous functions, and once with asynchronous functions. + +Take for example `fs.readFile` and `fs.readFileSync`, if you're writing an API +that loads a file and then performs a synchronous operation on the data, it +can be frustrating to maintain two parallel functions. + + +## Example + +```js +const fs = require("fs"); +const gensync = require("gensync"); + +const readFile = gensync({ + sync: fs.readFileSync, + errback: fs.readFile, +}); + +const myOperation = gensync(function* (filename) { + const code = yield* readFile(filename, "utf8"); + + return "// some custom prefix\n" + code; +}); + +// Load and add the prefix synchronously: +const result = myOperation.sync("./some-file.js"); + +// Load and add the prefix asynchronously with promises: +myOperation.async("./some-file.js").then(result => { + +}); + +// Load and add the prefix asynchronously with promises: +myOperation.errback("./some-file.js", (err, result) => { + +}); +``` + +This could even be exposed as your official API by doing +```js +// Using the common 'Sync' suffix for sync functions, and 'Async' suffix for +// promise-returning versions. +exports.myOperationSync = myOperation.sync; +exports.myOperationAsync = myOperation.async; +exports.myOperation = myOperation.errback; +``` +or potentially expose one of the async versions as the default, with a +`.sync` property on the function to expose the synchronous version. +```js +module.exports = myOperation.errback; +module.exports.sync = myOperation.sync; +```` + + +## API + +### gensync(generatorFnOrOptions) + +Returns a function that can be "await"-ed in another `gensync` generator +function, or executed via + +* `.sync(...args)` - Returns the computed value, or throws. +* `.async(...args)` - Returns a promise for the computed value. +* `.errback(...args, (err, result) => {})` - Calls the callback with the computed value, or error. + + +#### Passed a generator + +Wraps the generator to populate the `.sync`/`.async`/`.errback` helpers above to +allow for evaluation of the generator for the final value. + +##### Example + +```js +const readFile = function* () { + return 42; +}; + +const readFileAndMore = gensync(function* (){ + const val = yield* readFile(); + return 42 + val; +}); + +// In general cases +const code = readFileAndMore.sync("./file.js", "utf8"); +readFileAndMore.async("./file.js", "utf8").then(code => {}) +readFileAndMore.errback("./file.js", "utf8", (err, code) => {}); + +// In a generator being called indirectly with .sync/.async/.errback +const code = yield* readFileAndMore("./file.js", "utf8"); +``` + + +#### Passed an options object + +* `opts.sync` + + Example: `(...args) => 4` + + A function that will be called when `.sync()` is called on the `gensync()` + result, or when the result is passed to `yield*` in another generator that + is being run synchronously. + + Also called for `.async()` calls if no async handlers are provided. + +* `opts.async` + + Example: `async (...args) => 4` + + A function that will be called when `.async()` or `.errback()` is called on + the `gensync()` result, or when the result is passed to `yield*` in another + generator that is being run asynchronously. + +* `opts.errback` + + Example: `(...args, cb) => cb(null, 4)` + + A function that will be called when `.async()` or `.errback()` is called on + the `gensync()` result, or when the result is passed to `yield*` in another + generator that is being run asynchronously. + + This option allows for simpler compatibility with many existing Node APIs, + and also avoids introducing the extra even loop turns that promises introduce + to access the result value. + +* `opts.name` + + Example: `"readFile"` + + A string name to apply to the returned function. If no value is provided, + the name of `errback`/`async`/`sync` functions will be used, with any + `Sync` or `Async` suffix stripped off. If the callback is simply named + with ES6 inference (same name as the options property), the name is ignored. + +* `opts.arity` + + Example: `4` + + A number for the length to set on the returned function. If no value + is provided, the length will be carried over from the `sync` function's + `length` value. + +##### Example + +```js +const readFile = gensync({ + sync: fs.readFileSync, + errback: fs.readFile, +}); + +const code = readFile.sync("./file.js", "utf8"); +readFile.async("./file.js", "utf8").then(code => {}) +readFile.errback("./file.js", "utf8", (err, code) => {}); +``` + + +### gensync.all(iterable) + +`Promise.all`-like combinator that works with an iterable of generator objects +that could be passed to `yield*` within a gensync generator. + +#### Example + +```js +const loadFiles = gensync(function* () { + return yield* gensync.all([ + readFile("./one.js"), + readFile("./two.js"), + readFile("./three.js"), + ]); +}); +``` + + +### gensync.race(iterable) + +`Promise.race`-like combinator that works with an iterable of generator objects +that could be passed to `yield*` within a gensync generator. + +#### Example + +```js +const loadFiles = gensync(function* () { + return yield* gensync.race([ + readFile("./one.js"), + readFile("./two.js"), + readFile("./three.js"), + ]); +}); +``` diff --git a/tools/ui/node_modules/gensync/index.js b/tools/ui/node_modules/gensync/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ee0ea6165958e9213db75844fe6fd6ec96690f94 --- /dev/null +++ b/tools/ui/node_modules/gensync/index.js @@ -0,0 +1,373 @@ +"use strict"; + +// These use the global symbol registry so that multiple copies of this +// library can work together in case they are not deduped. +const GENSYNC_START = Symbol.for("gensync:v1:start"); +const GENSYNC_SUSPEND = Symbol.for("gensync:v1:suspend"); + +const GENSYNC_EXPECTED_START = "GENSYNC_EXPECTED_START"; +const GENSYNC_EXPECTED_SUSPEND = "GENSYNC_EXPECTED_SUSPEND"; +const GENSYNC_OPTIONS_ERROR = "GENSYNC_OPTIONS_ERROR"; +const GENSYNC_RACE_NONEMPTY = "GENSYNC_RACE_NONEMPTY"; +const GENSYNC_ERRBACK_NO_CALLBACK = "GENSYNC_ERRBACK_NO_CALLBACK"; + +module.exports = Object.assign( + function gensync(optsOrFn) { + let genFn = optsOrFn; + if (typeof optsOrFn !== "function") { + genFn = newGenerator(optsOrFn); + } else { + genFn = wrapGenerator(optsOrFn); + } + + return Object.assign(genFn, makeFunctionAPI(genFn)); + }, + { + all: buildOperation({ + name: "all", + arity: 1, + sync: function(args) { + const items = Array.from(args[0]); + return items.map(item => evaluateSync(item)); + }, + async: function(args, resolve, reject) { + const items = Array.from(args[0]); + + if (items.length === 0) { + Promise.resolve().then(() => resolve([])); + return; + } + + let count = 0; + const results = items.map(() => undefined); + items.forEach((item, i) => { + evaluateAsync( + item, + val => { + results[i] = val; + count += 1; + + if (count === results.length) resolve(results); + }, + reject + ); + }); + }, + }), + race: buildOperation({ + name: "race", + arity: 1, + sync: function(args) { + const items = Array.from(args[0]); + if (items.length === 0) { + throw makeError("Must race at least 1 item", GENSYNC_RACE_NONEMPTY); + } + + return evaluateSync(items[0]); + }, + async: function(args, resolve, reject) { + const items = Array.from(args[0]); + if (items.length === 0) { + throw makeError("Must race at least 1 item", GENSYNC_RACE_NONEMPTY); + } + + for (const item of items) { + evaluateAsync(item, resolve, reject); + } + }, + }), + } +); + +/** + * Given a generator function, return the standard API object that executes + * the generator and calls the callbacks. + */ +function makeFunctionAPI(genFn) { + const fns = { + sync: function(...args) { + return evaluateSync(genFn.apply(this, args)); + }, + async: function(...args) { + return new Promise((resolve, reject) => { + evaluateAsync(genFn.apply(this, args), resolve, reject); + }); + }, + errback: function(...args) { + const cb = args.pop(); + if (typeof cb !== "function") { + throw makeError( + "Asynchronous function called without callback", + GENSYNC_ERRBACK_NO_CALLBACK + ); + } + + let gen; + try { + gen = genFn.apply(this, args); + } catch (err) { + cb(err); + return; + } + + evaluateAsync(gen, val => cb(undefined, val), err => cb(err)); + }, + }; + return fns; +} + +function assertTypeof(type, name, value, allowUndefined) { + if ( + typeof value === type || + (allowUndefined && typeof value === "undefined") + ) { + return; + } + + let msg; + if (allowUndefined) { + msg = `Expected opts.${name} to be either a ${type}, or undefined.`; + } else { + msg = `Expected opts.${name} to be a ${type}.`; + } + + throw makeError(msg, GENSYNC_OPTIONS_ERROR); +} +function makeError(msg, code) { + return Object.assign(new Error(msg), { code }); +} + +/** + * Given an options object, return a new generator that dispatches the + * correct handler based on sync or async execution. + */ +function newGenerator({ name, arity, sync, async, errback }) { + assertTypeof("string", "name", name, true /* allowUndefined */); + assertTypeof("number", "arity", arity, true /* allowUndefined */); + assertTypeof("function", "sync", sync); + assertTypeof("function", "async", async, true /* allowUndefined */); + assertTypeof("function", "errback", errback, true /* allowUndefined */); + if (async && errback) { + throw makeError( + "Expected one of either opts.async or opts.errback, but got _both_.", + GENSYNC_OPTIONS_ERROR + ); + } + + if (typeof name !== "string") { + let fnName; + if (errback && errback.name && errback.name !== "errback") { + fnName = errback.name; + } + if (async && async.name && async.name !== "async") { + fnName = async.name.replace(/Async$/, ""); + } + if (sync && sync.name && sync.name !== "sync") { + fnName = sync.name.replace(/Sync$/, ""); + } + + if (typeof fnName === "string") { + name = fnName; + } + } + + if (typeof arity !== "number") { + arity = sync.length; + } + + return buildOperation({ + name, + arity, + sync: function(args) { + return sync.apply(this, args); + }, + async: function(args, resolve, reject) { + if (async) { + async.apply(this, args).then(resolve, reject); + } else if (errback) { + errback.call(this, ...args, (err, value) => { + if (err == null) resolve(value); + else reject(err); + }); + } else { + resolve(sync.apply(this, args)); + } + }, + }); +} + +function wrapGenerator(genFn) { + return setFunctionMetadata(genFn.name, genFn.length, function(...args) { + return genFn.apply(this, args); + }); +} + +function buildOperation({ name, arity, sync, async }) { + return setFunctionMetadata(name, arity, function*(...args) { + const resume = yield GENSYNC_START; + if (!resume) { + // Break the tail call to avoid a bug in V8 v6.X with --harmony enabled. + const res = sync.call(this, args); + return res; + } + + let result; + try { + async.call( + this, + args, + value => { + if (result) return; + + result = { value }; + resume(); + }, + err => { + if (result) return; + + result = { err }; + resume(); + } + ); + } catch (err) { + result = { err }; + resume(); + } + + // Suspend until the callbacks run. Will resume synchronously if the + // callback was already called. + yield GENSYNC_SUSPEND; + + if (result.hasOwnProperty("err")) { + throw result.err; + } + + return result.value; + }); +} + +function evaluateSync(gen) { + let value; + while (!({ value } = gen.next()).done) { + assertStart(value, gen); + } + return value; +} + +function evaluateAsync(gen, resolve, reject) { + (function step() { + try { + let value; + while (!({ value } = gen.next()).done) { + assertStart(value, gen); + + // If this throws, it is considered to have broken the contract + // established for async handlers. If these handlers are called + // synchronously, it is also considered bad behavior. + let sync = true; + let didSyncResume = false; + const out = gen.next(() => { + if (sync) { + didSyncResume = true; + } else { + step(); + } + }); + sync = false; + + assertSuspend(out, gen); + + if (!didSyncResume) { + // Callback wasn't called synchronously, so break out of the loop + // and let it call 'step' later. + return; + } + } + + return resolve(value); + } catch (err) { + return reject(err); + } + })(); +} + +function assertStart(value, gen) { + if (value === GENSYNC_START) return; + + throwError( + gen, + makeError( + `Got unexpected yielded value in gensync generator: ${JSON.stringify( + value + )}. Did you perhaps mean to use 'yield*' instead of 'yield'?`, + GENSYNC_EXPECTED_START + ) + ); +} +function assertSuspend({ value, done }, gen) { + if (!done && value === GENSYNC_SUSPEND) return; + + throwError( + gen, + makeError( + done + ? "Unexpected generator completion. If you get this, it is probably a gensync bug." + : `Expected GENSYNC_SUSPEND, got ${JSON.stringify( + value + )}. If you get this, it is probably a gensync bug.`, + GENSYNC_EXPECTED_SUSPEND + ) + ); +} + +function throwError(gen, err) { + // Call `.throw` so that users can step in a debugger to easily see which + // 'yield' passed an unexpected value. If the `.throw` call didn't throw + // back to the generator, we explicitly do it to stop the error + // from being swallowed by user code try/catches. + if (gen.throw) gen.throw(err); + throw err; +} + +function isIterable(value) { + return ( + !!value && + (typeof value === "object" || typeof value === "function") && + !value[Symbol.iterator] + ); +} + +function setFunctionMetadata(name, arity, fn) { + if (typeof name === "string") { + // This should always work on the supported Node versions, but for the + // sake of users that are compiling to older versions, we check for + // configurability so we don't throw. + const nameDesc = Object.getOwnPropertyDescriptor(fn, "name"); + if (!nameDesc || nameDesc.configurable) { + Object.defineProperty( + fn, + "name", + Object.assign(nameDesc || {}, { + configurable: true, + value: name, + }) + ); + } + } + + if (typeof arity === "number") { + const lengthDesc = Object.getOwnPropertyDescriptor(fn, "length"); + if (!lengthDesc || lengthDesc.configurable) { + Object.defineProperty( + fn, + "length", + Object.assign(lengthDesc || {}, { + configurable: true, + value: arity, + }) + ); + } + } + + return fn; +} diff --git a/tools/ui/node_modules/gensync/index.js.flow b/tools/ui/node_modules/gensync/index.js.flow new file mode 100644 index 0000000000000000000000000000000000000000..fa22e0bad9757fd441bcc8d70889730772c7c10c --- /dev/null +++ b/tools/ui/node_modules/gensync/index.js.flow @@ -0,0 +1,32 @@ +// @flow + +opaque type Next = Function | void; +opaque type Yield = mixed; + +export type Gensync = { + (...args: Args): Handler, + sync(...args: Args): Return, + async(...args: Args): Promise, + // ...args: [...Args, Callback] + errback(...args: any[]): void, +}; + +export type Handler = Generator; +export type Options = { + sync(...args: Args): Return, + arity?: number, + name?: string, +} & ( + | { async?: (...args: Args) => Promise } + // ...args: [...Args, Callback] + | { errback(...args: any[]): void } +); + +declare module.exports: { + ( + Options | ((...args: Args) => Handler) + ): Gensync, + + all(Array>): Handler, + race(Array>): Handler, +}; diff --git a/tools/ui/node_modules/gensync/package.json b/tools/ui/node_modules/gensync/package.json new file mode 100644 index 0000000000000000000000000000000000000000..07f87570d87b9111db75c195b2c5f7efeadf51ea --- /dev/null +++ b/tools/ui/node_modules/gensync/package.json @@ -0,0 +1,37 @@ +{ + "name": "gensync", + "version": "1.0.0-beta.2", + "license": "MIT", + "description": "Allows users to use generators in order to write common functions that can be both sync or async.", + "main": "index.js", + "author": "Logan Smyth ", + "homepage": "https://github.com/loganfsmyth/gensync", + "repository": { + "type": "git", + "url": "https://github.com/loganfsmyth/gensync.git" + }, + "scripts": { + "test": "jest" + }, + "engines": { + "node": ">=6.9.0" + }, + "keywords": [ + "async", + "sync", + "generators", + "async-await", + "callbacks" + ], + "devDependencies": { + "babel-core": "^6.26.3", + "babel-preset-env": "^1.6.1", + "eslint": "^4.19.1", + "eslint-config-prettier": "^2.9.0", + "eslint-plugin-node": "^6.0.1", + "eslint-plugin-prettier": "^2.6.0", + "flow-bin": "^0.71.0", + "jest": "^22.4.3", + "prettier": "^1.12.1" + } +} diff --git a/tools/ui/node_modules/gensync/test/.babelrc b/tools/ui/node_modules/gensync/test/.babelrc new file mode 100644 index 0000000000000000000000000000000000000000..cc7f4e98dce137e39533088e6bd4d719788a1a9e --- /dev/null +++ b/tools/ui/node_modules/gensync/test/.babelrc @@ -0,0 +1,5 @@ +{ + presets: [ + ["env", { targets: { node: "current" }}], + ], +} diff --git a/tools/ui/node_modules/gensync/test/index.test.js b/tools/ui/node_modules/gensync/test/index.test.js new file mode 100644 index 0000000000000000000000000000000000000000..ca1a2695e9f328dfe12b0347e6658c571add39cb --- /dev/null +++ b/tools/ui/node_modules/gensync/test/index.test.js @@ -0,0 +1,489 @@ +"use strict"; + +const promisify = require("util.promisify"); +const gensync = require("../"); + +const TEST_ERROR = new Error("TEST_ERROR"); + +const DID_ERROR = new Error("DID_ERROR"); + +const doSuccess = gensync({ + sync: () => 42, + async: () => Promise.resolve(42), +}); + +const doError = gensync({ + sync: () => { + throw DID_ERROR; + }, + async: () => Promise.reject(DID_ERROR), +}); + +function throwTestError() { + throw TEST_ERROR; +} + +async function expectResult( + fn, + arg, + { error, value, expectSync = false, syncErrback = expectSync } +) { + if (!expectSync) { + expect(() => fn.sync(arg)).toThrow(TEST_ERROR); + } else if (error) { + expect(() => fn.sync(arg)).toThrow(error); + } else { + expect(fn.sync(arg)).toBe(value); + } + + if (error) { + await expect(fn.async(arg)).rejects.toBe(error); + } else { + await expect(fn.async(arg)).resolves.toBe(value); + } + + await new Promise((resolve, reject) => { + let sync = true; + fn.errback(arg, (err, val) => { + try { + expect(err).toBe(error); + expect(val).toBe(value); + expect(sync).toBe(syncErrback); + + resolve(); + } catch (e) { + reject(e); + } + }); + sync = false; + }); +} + +describe("gensync({})", () => { + describe("option validation", () => { + test("disallow async and errback handler together", () => { + try { + gensync({ + sync: throwTestError, + async: throwTestError, + errback: throwTestError, + }); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch( + /Expected one of either opts.async or opts.errback, but got _both_\./ + ); + expect(err.code).toBe("GENSYNC_OPTIONS_ERROR"); + } + }); + + test("disallow missing sync handler", () => { + try { + gensync({ + async: throwTestError, + }); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch(/Expected opts.sync to be a function./); + expect(err.code).toBe("GENSYNC_OPTIONS_ERROR"); + } + }); + + test("errback callback required", () => { + const fn = gensync({ + sync: throwTestError, + async: throwTestError, + }); + + try { + fn.errback(); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch(/function called without callback/); + expect(err.code).toBe("GENSYNC_ERRBACK_NO_CALLBACK"); + } + }); + }); + + describe("generator function metadata", () => { + test("automatic naming", () => { + expect( + gensync({ + sync: function readFileSync() {}, + async: () => {}, + }).name + ).toBe("readFile"); + expect( + gensync({ + sync: function readFile() {}, + async: () => {}, + }).name + ).toBe("readFile"); + expect( + gensync({ + sync: function readFileAsync() {}, + async: () => {}, + }).name + ).toBe("readFileAsync"); + + expect( + gensync({ + sync: () => {}, + async: function readFileSync() {}, + }).name + ).toBe("readFileSync"); + expect( + gensync({ + sync: () => {}, + async: function readFile() {}, + }).name + ).toBe("readFile"); + expect( + gensync({ + sync: () => {}, + async: function readFileAsync() {}, + }).name + ).toBe("readFile"); + + expect( + gensync({ + sync: () => {}, + errback: function readFileSync() {}, + }).name + ).toBe("readFileSync"); + expect( + gensync({ + sync: () => {}, + errback: function readFile() {}, + }).name + ).toBe("readFile"); + expect( + gensync({ + sync: () => {}, + errback: function readFileAsync() {}, + }).name + ).toBe("readFileAsync"); + }); + + test("explicit naming", () => { + expect( + gensync({ + name: "readFile", + sync: () => {}, + async: () => {}, + }).name + ).toBe("readFile"); + }); + + test("default arity", () => { + expect( + gensync({ + sync: function(a, b, c, d, e, f, g) { + throwTestError(); + }, + async: throwTestError, + }).length + ).toBe(7); + }); + + test("explicit arity", () => { + expect( + gensync({ + arity: 3, + sync: throwTestError, + async: throwTestError, + }).length + ).toBe(3); + }); + }); + + describe("'sync' handler", async () => { + test("success", async () => { + const fn = gensync({ + sync: (...args) => JSON.stringify(args), + }); + + await expectResult(fn, 42, { value: "[42]", expectSync: true }); + }); + + test("failure", async () => { + const fn = gensync({ + sync: (...args) => { + throw JSON.stringify(args); + }, + }); + + await expectResult(fn, 42, { error: "[42]", expectSync: true }); + }); + }); + + describe("'async' handler", async () => { + test("success", async () => { + const fn = gensync({ + sync: throwTestError, + async: (...args) => Promise.resolve(JSON.stringify(args)), + }); + + await expectResult(fn, 42, { value: "[42]" }); + }); + + test("failure", async () => { + const fn = gensync({ + sync: throwTestError, + async: (...args) => Promise.reject(JSON.stringify(args)), + }); + + await expectResult(fn, 42, { error: "[42]" }); + }); + }); + + describe("'errback' sync handler", async () => { + test("success", async () => { + const fn = gensync({ + sync: throwTestError, + errback: (...args) => args.pop()(null, JSON.stringify(args)), + }); + + await expectResult(fn, 42, { value: "[42]", syncErrback: true }); + }); + + test("failure", async () => { + const fn = gensync({ + sync: throwTestError, + errback: (...args) => args.pop()(JSON.stringify(args)), + }); + + await expectResult(fn, 42, { error: "[42]", syncErrback: true }); + }); + }); + + describe("'errback' async handler", async () => { + test("success", async () => { + const fn = gensync({ + sync: throwTestError, + errback: (...args) => + process.nextTick(() => args.pop()(null, JSON.stringify(args))), + }); + + await expectResult(fn, 42, { value: "[42]" }); + }); + + test("failure", async () => { + const fn = gensync({ + sync: throwTestError, + errback: (...args) => + process.nextTick(() => args.pop()(JSON.stringify(args))), + }); + + await expectResult(fn, 42, { error: "[42]" }); + }); + }); +}); + +describe("gensync(function* () {})", () => { + test("sync throw before body", async () => { + const fn = gensync(function*(arg = throwTestError()) {}); + + await expectResult(fn, undefined, { + error: TEST_ERROR, + syncErrback: true, + }); + }); + + test("sync throw inside body", async () => { + const fn = gensync(function*() { + throwTestError(); + }); + + await expectResult(fn, undefined, { + error: TEST_ERROR, + syncErrback: true, + }); + }); + + test("async throw inside body", async () => { + const fn = gensync(function*() { + const val = yield* doSuccess(); + throwTestError(); + }); + + await expectResult(fn, undefined, { + error: TEST_ERROR, + }); + }); + + test("error inside body", async () => { + const fn = gensync(function*() { + yield* doError(); + }); + + await expectResult(fn, undefined, { + error: DID_ERROR, + expectSync: true, + syncErrback: false, + }); + }); + + test("successful return value", async () => { + const fn = gensync(function*() { + const value = yield* doSuccess(); + + expect(value).toBe(42); + + return 84; + }); + + await expectResult(fn, undefined, { + value: 84, + expectSync: true, + syncErrback: false, + }); + }); + + test("successful final value", async () => { + const fn = gensync(function*() { + return 42; + }); + + await expectResult(fn, undefined, { + value: 42, + expectSync: true, + }); + }); + + test("yield unexpected object", async () => { + const fn = gensync(function*() { + yield {}; + }); + + try { + await fn.async(); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch( + /Got unexpected yielded value in gensync generator/ + ); + expect(err.code).toBe("GENSYNC_EXPECTED_START"); + } + }); + + test("yield suspend yield", async () => { + const fn = gensync(function*() { + yield Symbol.for("gensync:v1:start"); + + // Should be "yield*" for no error. + yield {}; + }); + + try { + await fn.async(); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch(/Expected GENSYNC_SUSPEND, got {}/); + expect(err.code).toBe("GENSYNC_EXPECTED_SUSPEND"); + } + }); + + test("yield suspend return", async () => { + const fn = gensync(function*() { + yield Symbol.for("gensync:v1:start"); + + // Should be "yield*" for no error. + return {}; + }); + + try { + await fn.async(); + + throwTestError(); + } catch (err) { + expect(err.message).toMatch(/Unexpected generator completion/); + expect(err.code).toBe("GENSYNC_EXPECTED_SUSPEND"); + } + }); +}); + +describe("gensync.all()", () => { + test("success", async () => { + const fn = gensync(function*() { + const result = yield* gensync.all([doSuccess(), doSuccess()]); + + expect(result).toEqual([42, 42]); + }); + + await expectResult(fn, undefined, { + value: undefined, + expectSync: true, + syncErrback: false, + }); + }); + + test("error first", async () => { + const fn = gensync(function*() { + yield* gensync.all([doError(), doSuccess()]); + }); + + await expectResult(fn, undefined, { + error: DID_ERROR, + expectSync: true, + syncErrback: false, + }); + }); + + test("error last", async () => { + const fn = gensync(function*() { + yield* gensync.all([doSuccess(), doError()]); + }); + + await expectResult(fn, undefined, { + error: DID_ERROR, + expectSync: true, + syncErrback: false, + }); + }); + + test("empty list", async () => { + const fn = gensync(function*() { + yield* gensync.all([]); + }); + + await expectResult(fn, undefined, { + value: undefined, + expectSync: true, + syncErrback: false, + }); + }); +}); + +describe("gensync.race()", () => { + test("success", async () => { + const fn = gensync(function*() { + const result = yield* gensync.race([doSuccess(), doError()]); + + expect(result).toEqual(42); + }); + + await expectResult(fn, undefined, { + value: undefined, + expectSync: true, + syncErrback: false, + }); + }); + + test("error", async () => { + const fn = gensync(function*() { + yield* gensync.race([doError(), doSuccess()]); + }); + + await expectResult(fn, undefined, { + error: DID_ERROR, + expectSync: true, + syncErrback: false, + }); + }); +}); diff --git a/tools/ui/node_modules/get-intrinsic/.eslintrc b/tools/ui/node_modules/get-intrinsic/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..235fb79a2521611644ab093c3d739c8d90617818 --- /dev/null +++ b/tools/ui/node_modules/get-intrinsic/.eslintrc @@ -0,0 +1,42 @@ +{ + "root": true, + + "extends": "@ljharb", + + "env": { + "es6": true, + "es2017": true, + "es2020": true, + "es2021": true, + "es2022": true, + }, + + "globals": { + "Float16Array": false, + }, + + "rules": { + "array-bracket-newline": 0, + "complexity": 0, + "eqeqeq": [2, "allow-null"], + "func-name-matching": 0, + "id-length": 0, + "max-lines": 0, + "max-lines-per-function": [2, 90], + "max-params": [2, 4], + "max-statements": 0, + "max-statements-per-line": [2, { "max": 2 }], + "multiline-comment-style": 0, + "no-magic-numbers": 0, + "sort-keys": 0, + }, + + "overrides": [ + { + "files": "test/**", + "rules": { + "new-cap": 0, + }, + }, + ], +} diff --git a/tools/ui/node_modules/get-intrinsic/.github/FUNDING.yml b/tools/ui/node_modules/get-intrinsic/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..8e8da0dda153deb6bf1bfbb2c1a7e5e19aea08c5 --- /dev/null +++ b/tools/ui/node_modules/get-intrinsic/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/get-intrinsic +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/get-intrinsic/.nycrc b/tools/ui/node_modules/get-intrinsic/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..bdd626ce91477abbdd489b79988baebadbd3c897 --- /dev/null +++ b/tools/ui/node_modules/get-intrinsic/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/get-intrinsic/CHANGELOG.md b/tools/ui/node_modules/get-intrinsic/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..ce1dd98713317a95f0a72036434478172fe991d8 --- /dev/null +++ b/tools/ui/node_modules/get-intrinsic/CHANGELOG.md @@ -0,0 +1,186 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.3.0](https://github.com/ljharb/get-intrinsic/compare/v1.2.7...v1.3.0) - 2025-02-22 + +### Commits + +- [Dev Deps] update `es-abstract`, `es-value-fixtures`, `for-each`, `object-inspect` [`9b61553`](https://github.com/ljharb/get-intrinsic/commit/9b61553c587f1c1edbd435597e88c7d387da97dd) +- [Deps] update `call-bind-apply-helpers`, `es-object-atoms`, `get-proto` [`a341fee`](https://github.com/ljharb/get-intrinsic/commit/a341fee0f39a403b0f0069e82c97642d5eb11043) +- [New] add `Float16Array` [`de22116`](https://github.com/ljharb/get-intrinsic/commit/de22116b492fb989a0341bceb6e573abfaed73dc) + +## [v1.2.7](https://github.com/ljharb/get-intrinsic/compare/v1.2.6...v1.2.7) - 2025-01-02 + +### Commits + +- [Refactor] use `get-proto` directly [`00ab955`](https://github.com/ljharb/get-intrinsic/commit/00ab95546a0980c8ad42a84253daaa8d2adcedf9) +- [Deps] update `math-intrinsics` [`c716cdd`](https://github.com/ljharb/get-intrinsic/commit/c716cdd6bbe36b438057025561b8bb5a879ac8a0) +- [Dev Deps] update `call-bound`, `es-abstract` [`dc648a6`](https://github.com/ljharb/get-intrinsic/commit/dc648a67eb359037dff8d8619bfa71d86debccb1) + +## [v1.2.6](https://github.com/ljharb/get-intrinsic/compare/v1.2.5...v1.2.6) - 2024-12-11 + +### Commits + +- [Refactor] use `math-intrinsics` [`841be86`](https://github.com/ljharb/get-intrinsic/commit/841be8641a9254c4c75483b30c8871b5d5065926) +- [Refactor] use `es-object-atoms` [`42057df`](https://github.com/ljharb/get-intrinsic/commit/42057dfa16f66f64787e66482af381cc6f31d2c1) +- [Deps] update `call-bind-apply-helpers` [`45afa24`](https://github.com/ljharb/get-intrinsic/commit/45afa24a9ee4d6d3c172db1f555b16cb27843ef4) +- [Dev Deps] update `call-bound` [`9cba9c6`](https://github.com/ljharb/get-intrinsic/commit/9cba9c6e70212bc163b7a5529cb25df46071646f) + +## [v1.2.5](https://github.com/ljharb/get-intrinsic/compare/v1.2.4...v1.2.5) - 2024-12-06 + +### Commits + +- [actions] split out node 10-20, and 20+ [`6e2b9dd`](https://github.com/ljharb/get-intrinsic/commit/6e2b9dd23902665681ebe453256ccfe21d7966f0) +- [Refactor] use `dunder-proto` and `call-bind-apply-helpers` instead of `has-proto` [`c095d17`](https://github.com/ljharb/get-intrinsic/commit/c095d179ad0f4fbfff20c8a3e0cb4fe668018998) +- [Refactor] use `gopd` [`9841d5b`](https://github.com/ljharb/get-intrinsic/commit/9841d5b35f7ab4fd2d193f0c741a50a077920e90) +- [Dev Deps] update `@ljharb/eslint-config`, `auto-changelog`, `es-abstract`, `es-value-fixtures`, `gopd`, `mock-property`, `object-inspect`, `tape` [`2d07e01`](https://github.com/ljharb/get-intrinsic/commit/2d07e01310cee2cbaedfead6903df128b1f5d425) +- [Deps] update `gopd`, `has-proto`, `has-symbols`, `hasown` [`974d8bf`](https://github.com/ljharb/get-intrinsic/commit/974d8bf5baad7939eef35c25cc1dd88c10a30fa6) +- [Dev Deps] update `call-bind`, `es-abstract`, `tape` [`df9dde1`](https://github.com/ljharb/get-intrinsic/commit/df9dde178186631ab8a3165ede056549918ce4bc) +- [Refactor] cache `es-define-property` as well [`43ef543`](https://github.com/ljharb/get-intrinsic/commit/43ef543cb02194401420e3a914a4ca9168691926) +- [Deps] update `has-proto`, `has-symbols`, `hasown` [`ad4949d`](https://github.com/ljharb/get-intrinsic/commit/ad4949d5467316505aad89bf75f9417ed782f7af) +- [Tests] use `call-bound` directly [`ad5c406`](https://github.com/ljharb/get-intrinsic/commit/ad5c4069774bfe90e520a35eead5fe5ca9d69e80) +- [Deps] update `has-proto`, `hasown` [`45414ca`](https://github.com/ljharb/get-intrinsic/commit/45414caa312333a2798953682c68f85c550627dd) +- [Tests] replace `aud` with `npm audit` [`18d3509`](https://github.com/ljharb/get-intrinsic/commit/18d3509f79460e7924da70409ee81e5053087523) +- [Deps] update `es-define-property` [`aadaa3b`](https://github.com/ljharb/get-intrinsic/commit/aadaa3b2188d77ad9bff394ce5d4249c49eb21f5) +- [Dev Deps] add missing peer dep [`c296a16`](https://github.com/ljharb/get-intrinsic/commit/c296a16246d0c9a5981944f4cc5cf61fbda0cf6a) + +## [v1.2.4](https://github.com/ljharb/get-intrinsic/compare/v1.2.3...v1.2.4) - 2024-02-05 + +### Commits + +- [Refactor] use all 7 <+ ES6 Errors from `es-errors` [`bcac811`](https://github.com/ljharb/get-intrinsic/commit/bcac811abdc1c982e12abf848a410d6aae148d14) + +## [v1.2.3](https://github.com/ljharb/get-intrinsic/compare/v1.2.2...v1.2.3) - 2024-02-03 + +### Commits + +- [Refactor] use `es-errors`, so things that only need those do not need `get-intrinsic` [`f11db9c`](https://github.com/ljharb/get-intrinsic/commit/f11db9c4fb97d87bbd53d3c73ac6b3db3613ad3b) +- [Dev Deps] update `aud`, `es-abstract`, `mock-property`, `npmignore` [`b7ac7d1`](https://github.com/ljharb/get-intrinsic/commit/b7ac7d1616fefb03877b1aed0c8f8d61aad32b6c) +- [meta] simplify `exports` [`faa0cc6`](https://github.com/ljharb/get-intrinsic/commit/faa0cc618e2830ffb51a8202490b0c215d965cbc) +- [meta] add missing `engines.node` [`774dd0b`](https://github.com/ljharb/get-intrinsic/commit/774dd0b3e8f741c3f05a6322d124d6087f146af1) +- [Dev Deps] update `tape` [`5828e8e`](https://github.com/ljharb/get-intrinsic/commit/5828e8e4a04e69312e87a36c0ea39428a7a4c3d8) +- [Robustness] use null objects for lookups [`eb9a11f`](https://github.com/ljharb/get-intrinsic/commit/eb9a11fa9eb3e13b193fcc05a7fb814341b1a7b7) +- [meta] add `sideEffects` flag [`89bcc7a`](https://github.com/ljharb/get-intrinsic/commit/89bcc7a42e19bf07b7c21e3094d5ab177109e6d2) + +## [v1.2.2](https://github.com/ljharb/get-intrinsic/compare/v1.2.1...v1.2.2) - 2023-10-20 + +### Commits + +- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `call-bind`, `es-abstract`, `mock-property`, `object-inspect`, `tape` [`f51bcf2`](https://github.com/ljharb/get-intrinsic/commit/f51bcf26412d58d17ce17c91c9afd0ad271f0762) +- [Refactor] use `hasown` instead of `has` [`18d14b7`](https://github.com/ljharb/get-intrinsic/commit/18d14b799bea6b5765e1cec91890830cbcdb0587) +- [Deps] update `function-bind` [`6e109c8`](https://github.com/ljharb/get-intrinsic/commit/6e109c81e03804cc5e7824fb64353cdc3d8ee2c7) + +## [v1.2.1](https://github.com/ljharb/get-intrinsic/compare/v1.2.0...v1.2.1) - 2023-05-13 + +### Commits + +- [Fix] avoid a crash in envs without `__proto__` [`7bad8d0`](https://github.com/ljharb/get-intrinsic/commit/7bad8d061bf8721733b58b73a2565af2b6756b64) +- [Dev Deps] update `es-abstract` [`c60e6b7`](https://github.com/ljharb/get-intrinsic/commit/c60e6b7b4cf9660c7f27ed970970fd55fac48dc5) + +## [v1.2.0](https://github.com/ljharb/get-intrinsic/compare/v1.1.3...v1.2.0) - 2023-01-19 + +### Commits + +- [actions] update checkout action [`ca6b12f`](https://github.com/ljharb/get-intrinsic/commit/ca6b12f31eaacea4ea3b055e744cd61623385ffb) +- [Dev Deps] update `@ljharb/eslint-config`, `es-abstract`, `object-inspect`, `tape` [`41a3727`](https://github.com/ljharb/get-intrinsic/commit/41a3727d0026fa04273ae216a5f8e12eefd72da8) +- [Fix] ensure `Error.prototype` is undeniable [`c511e97`](https://github.com/ljharb/get-intrinsic/commit/c511e97ae99c764c4524b540dee7a70757af8da3) +- [Dev Deps] update `aud`, `es-abstract`, `tape` [`1bef8a8`](https://github.com/ljharb/get-intrinsic/commit/1bef8a8fd439ebb80863199b6189199e0851ac67) +- [Dev Deps] update `aud`, `es-abstract` [`0d41f16`](https://github.com/ljharb/get-intrinsic/commit/0d41f16bcd500bc28b7bfc98043ebf61ea081c26) +- [New] add `BigInt64Array` and `BigUint64Array` [`a6cca25`](https://github.com/ljharb/get-intrinsic/commit/a6cca25f29635889b7e9bd669baf9e04be90e48c) +- [Tests] use `gopd` [`ecf7722`](https://github.com/ljharb/get-intrinsic/commit/ecf7722240d15cfd16edda06acf63359c10fb9bd) + +## [v1.1.3](https://github.com/ljharb/get-intrinsic/compare/v1.1.2...v1.1.3) - 2022-09-12 + +### Commits + +- [Dev Deps] update `es-abstract`, `es-value-fixtures`, `tape` [`07ff291`](https://github.com/ljharb/get-intrinsic/commit/07ff291816406ebe5a12d7f16965bde0942dd688) +- [Fix] properly check for % signs [`50ac176`](https://github.com/ljharb/get-intrinsic/commit/50ac1760fe99c227e64eabde76e9c0e44cd881b5) + +## [v1.1.2](https://github.com/ljharb/get-intrinsic/compare/v1.1.1...v1.1.2) - 2022-06-08 + +### Fixed + +- [Fix] properly validate against extra % signs [`#16`](https://github.com/ljharb/get-intrinsic/issues/16) + +### Commits + +- [actions] reuse common workflows [`0972547`](https://github.com/ljharb/get-intrinsic/commit/0972547efd0abc863fe4c445a6ca7eb4f8c6901d) +- [meta] use `npmignore` to autogenerate an npmignore file [`5ba0b51`](https://github.com/ljharb/get-intrinsic/commit/5ba0b51d8d8d4f1c31d426d74abc0770fd106bad) +- [actions] use `node/install` instead of `node/run`; use `codecov` action [`c364492`](https://github.com/ljharb/get-intrinsic/commit/c364492af4af51333e6f81c0bf21fd3d602c3661) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `es-abstract`, `object-inspect`, `tape` [`dc04dad`](https://github.com/ljharb/get-intrinsic/commit/dc04dad86f6e5608775a2640cb0db5927ae29ed9) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `es-abstract`, `object-inspect`, `safe-publish-latest`, `tape` [`1c14059`](https://github.com/ljharb/get-intrinsic/commit/1c1405984e86dd2dc9366c15d8a0294a96a146a5) +- [Tests] use `mock-property` [`b396ef0`](https://github.com/ljharb/get-intrinsic/commit/b396ef05bb73b1d699811abd64b0d9b97997fdda) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `object-inspect`, `tape` [`c2c758d`](https://github.com/ljharb/get-intrinsic/commit/c2c758d3b90af4fef0a76910d8d3c292ec8d1d3e) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `es-abstract`, `es-value-fixtures`, `object-inspect`, `tape` [`29e3c09`](https://github.com/ljharb/get-intrinsic/commit/29e3c091c2bf3e17099969847e8729d0e46896de) +- [actions] update codecov uploader [`8cbc141`](https://github.com/ljharb/get-intrinsic/commit/8cbc1418940d7a8941f3a7985cbc4ac095c5e13d) +- [Dev Deps] update `@ljharb/eslint-config`, `es-abstract`, `es-value-fixtures`, `object-inspect`, `tape` [`10b6f5c`](https://github.com/ljharb/get-intrinsic/commit/10b6f5c02593fb3680c581d696ac124e30652932) +- [readme] add github actions/codecov badges [`4e25400`](https://github.com/ljharb/get-intrinsic/commit/4e25400d9f51ae9eb059cbe22d9144e70ea214e8) +- [Tests] use `for-each` instead of `foreach` [`c05b957`](https://github.com/ljharb/get-intrinsic/commit/c05b957ad9a7bc7721af7cc9e9be1edbfe057496) +- [Dev Deps] update `es-abstract` [`29b05ae`](https://github.com/ljharb/get-intrinsic/commit/29b05aec3e7330e9ad0b8e0f685a9112c20cdd97) +- [meta] use `prepublishOnly` script for npm 7+ [`95c285d`](https://github.com/ljharb/get-intrinsic/commit/95c285da810516057d3bbfa871176031af38f05d) +- [Deps] update `has-symbols` [`593cb4f`](https://github.com/ljharb/get-intrinsic/commit/593cb4fb38e7922e40e42c183f45274b636424cd) +- [readme] fix repo URLs [`1c8305b`](https://github.com/ljharb/get-intrinsic/commit/1c8305b5365827c9b6fc785434aac0e1328ff2f5) +- [Deps] update `has-symbols` [`c7138b6`](https://github.com/ljharb/get-intrinsic/commit/c7138b6c6d73132d859471fb8c13304e1e7c8b20) +- [Dev Deps] remove unused `has-bigints` [`bd63aff`](https://github.com/ljharb/get-intrinsic/commit/bd63aff6ad8f3a986c557fcda2914187bdaab359) + +## [v1.1.1](https://github.com/ljharb/get-intrinsic/compare/v1.1.0...v1.1.1) - 2021-02-03 + +### Fixed + +- [meta] export `./package.json` [`#9`](https://github.com/ljharb/get-intrinsic/issues/9) + +### Commits + +- [readme] flesh out the readme; use `evalmd` [`d12f12c`](https://github.com/ljharb/get-intrinsic/commit/d12f12c15345a0a0772cc65a7c64369529abd614) +- [eslint] set up proper globals config [`5a8c098`](https://github.com/ljharb/get-intrinsic/commit/5a8c0984e3319d1ac0e64b102f8ec18b64e79f36) +- [Dev Deps] update `eslint` [`7b9a5c0`](https://github.com/ljharb/get-intrinsic/commit/7b9a5c0d31a90ca1a1234181c74988fb046701cd) + +## [v1.1.0](https://github.com/ljharb/get-intrinsic/compare/v1.0.2...v1.1.0) - 2021-01-25 + +### Fixed + +- [Refactor] delay `Function` eval until syntax-derived values are requested [`#3`](https://github.com/ljharb/get-intrinsic/issues/3) + +### Commits + +- [Tests] migrate tests to Github Actions [`2ab762b`](https://github.com/ljharb/get-intrinsic/commit/2ab762b48164aea8af37a40ba105bbc8246ab8c4) +- [meta] do not publish github action workflow files [`5e7108e`](https://github.com/ljharb/get-intrinsic/commit/5e7108e4768b244d48d9567ba4f8a6cab9c65b8e) +- [Tests] add some coverage [`01ac7a8`](https://github.com/ljharb/get-intrinsic/commit/01ac7a87ac29738567e8524cd8c9e026b1fa8cb3) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `call-bind`, `es-abstract`, `tape`; add `call-bind` [`911b672`](https://github.com/ljharb/get-intrinsic/commit/911b672fbffae433a96924c6ce013585e425f4b7) +- [Refactor] rearrange evalled constructors a bit [`7e7e4bf`](https://github.com/ljharb/get-intrinsic/commit/7e7e4bf583f3799c8ac1c6c5e10d2cb553957347) +- [meta] add Automatic Rebase and Require Allow Edits workflows [`0199968`](https://github.com/ljharb/get-intrinsic/commit/01999687a263ffce0a3cb011dfbcb761754aedbc) + +## [v1.0.2](https://github.com/ljharb/get-intrinsic/compare/v1.0.1...v1.0.2) - 2020-12-17 + +### Commits + +- [Fix] Throw for non‑existent intrinsics [`68f873b`](https://github.com/ljharb/get-intrinsic/commit/68f873b013c732a05ad6f5fc54f697e55515461b) +- [Fix] Throw for non‑existent segments in the intrinsic path [`8325dee`](https://github.com/ljharb/get-intrinsic/commit/8325deee43128f3654d3399aa9591741ebe17b21) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `has-bigints`, `object-inspect` [`0c227a7`](https://github.com/ljharb/get-intrinsic/commit/0c227a7d8b629166f25715fd242553892e458525) +- [meta] do not lint coverage output [`70d2419`](https://github.com/ljharb/get-intrinsic/commit/70d24199b620043cd9110fc5f426d214ebe21dc9) + +## [v1.0.1](https://github.com/ljharb/get-intrinsic/compare/v1.0.0...v1.0.1) - 2020-10-30 + +### Commits + +- [Tests] gather coverage data on every job [`d1d280d`](https://github.com/ljharb/get-intrinsic/commit/d1d280dec714e3f0519cc877dbcb193057d9cac6) +- [Fix] add missing dependencies [`5031771`](https://github.com/ljharb/get-intrinsic/commit/5031771bb1095b38be88ce7c41d5de88718e432e) +- [Tests] use `es-value-fixtures` [`af48765`](https://github.com/ljharb/get-intrinsic/commit/af48765a23c5323fb0b6b38dbf00eb5099c7bebc) + +## v1.0.0 - 2020-10-29 + +### Commits + +- Implementation [`bbce57c`](https://github.com/ljharb/get-intrinsic/commit/bbce57c6f33d05b2d8d3efa273ceeb3ee01127bb) +- Tests [`17b4f0d`](https://github.com/ljharb/get-intrinsic/commit/17b4f0d56dea6b4059b56fc30ef3ee4d9500ebc2) +- Initial commit [`3153294`](https://github.com/ljharb/get-intrinsic/commit/31532948de363b0a27dd9fd4649e7b7028ec4b44) +- npm init [`fb326c4`](https://github.com/ljharb/get-intrinsic/commit/fb326c4d2817c8419ec31de1295f06bb268a7902) +- [meta] add Automatic Rebase and Require Allow Edits workflows [`48862fb`](https://github.com/ljharb/get-intrinsic/commit/48862fb2508c8f6a57968e6d08b7c883afc9d550) +- [meta] add `auto-changelog` [`5f28ad0`](https://github.com/ljharb/get-intrinsic/commit/5f28ad019e060a353d8028f9f2591a9cc93074a1) +- [meta] add "funding"; create `FUNDING.yml` [`c2bbdde`](https://github.com/ljharb/get-intrinsic/commit/c2bbddeba73a875be61484ee4680b129a6d4e0a1) +- [Tests] add `npm run lint` [`0a84b98`](https://github.com/ljharb/get-intrinsic/commit/0a84b98b22b7cf7a748666f705b0003a493c35fd) +- Only apps should have lockfiles [`9586c75`](https://github.com/ljharb/get-intrinsic/commit/9586c75866c1ee678e4d5d4dbbdef6997e511b05) diff --git a/tools/ui/node_modules/get-intrinsic/LICENSE b/tools/ui/node_modules/get-intrinsic/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..48f05d01d0acae75acada5bd42a3442d0699d067 --- /dev/null +++ b/tools/ui/node_modules/get-intrinsic/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020 Jordan Harband + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/get-intrinsic/README.md b/tools/ui/node_modules/get-intrinsic/README.md new file mode 100644 index 0000000000000000000000000000000000000000..3aa0bba4037e57211920a2cf8b57194b61eb24d9 --- /dev/null +++ b/tools/ui/node_modules/get-intrinsic/README.md @@ -0,0 +1,71 @@ +# get-intrinsic [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +Get and robustly cache all JS language-level intrinsics at first require time. + +See the syntax described [in the JS spec](https://tc39.es/ecma262/#sec-well-known-intrinsic-objects) for reference. + +## Example + +```js +var GetIntrinsic = require('get-intrinsic'); +var assert = require('assert'); + +// static methods +assert.equal(GetIntrinsic('%Math.pow%'), Math.pow); +assert.equal(Math.pow(2, 3), 8); +assert.equal(GetIntrinsic('%Math.pow%')(2, 3), 8); +delete Math.pow; +assert.equal(GetIntrinsic('%Math.pow%')(2, 3), 8); + +// instance methods +var arr = [1]; +assert.equal(GetIntrinsic('%Array.prototype.push%'), Array.prototype.push); +assert.deepEqual(arr, [1]); + +arr.push(2); +assert.deepEqual(arr, [1, 2]); + +GetIntrinsic('%Array.prototype.push%').call(arr, 3); +assert.deepEqual(arr, [1, 2, 3]); + +delete Array.prototype.push; +GetIntrinsic('%Array.prototype.push%').call(arr, 4); +assert.deepEqual(arr, [1, 2, 3, 4]); + +// missing features +delete JSON.parse; // to simulate a real intrinsic that is missing in the environment +assert.throws(() => GetIntrinsic('%JSON.parse%')); +assert.equal(undefined, GetIntrinsic('%JSON.parse%', true)); +``` + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +## Security + +Please email [@ljharb](https://github.com/ljharb) or see https://tidelift.com/security if you have a potential security vulnerability to report. + +[package-url]: https://npmjs.org/package/get-intrinsic +[npm-version-svg]: https://versionbadg.es/ljharb/get-intrinsic.svg +[deps-svg]: https://david-dm.org/ljharb/get-intrinsic.svg +[deps-url]: https://david-dm.org/ljharb/get-intrinsic +[dev-deps-svg]: https://david-dm.org/ljharb/get-intrinsic/dev-status.svg +[dev-deps-url]: https://david-dm.org/ljharb/get-intrinsic#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/get-intrinsic.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/get-intrinsic.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/get-intrinsic.svg +[downloads-url]: https://npm-stat.com/charts.html?package=get-intrinsic +[codecov-image]: https://codecov.io/gh/ljharb/get-intrinsic/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/ljharb/get-intrinsic/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/ljharb/get-intrinsic +[actions-url]: https://github.com/ljharb/get-intrinsic/actions diff --git a/tools/ui/node_modules/get-intrinsic/index.js b/tools/ui/node_modules/get-intrinsic/index.js new file mode 100644 index 0000000000000000000000000000000000000000..bd1d94b7f12eb2144fd68163e6481ad0e5f2b70a --- /dev/null +++ b/tools/ui/node_modules/get-intrinsic/index.js @@ -0,0 +1,378 @@ +'use strict'; + +var undefined; + +var $Object = require('es-object-atoms'); + +var $Error = require('es-errors'); +var $EvalError = require('es-errors/eval'); +var $RangeError = require('es-errors/range'); +var $ReferenceError = require('es-errors/ref'); +var $SyntaxError = require('es-errors/syntax'); +var $TypeError = require('es-errors/type'); +var $URIError = require('es-errors/uri'); + +var abs = require('math-intrinsics/abs'); +var floor = require('math-intrinsics/floor'); +var max = require('math-intrinsics/max'); +var min = require('math-intrinsics/min'); +var pow = require('math-intrinsics/pow'); +var round = require('math-intrinsics/round'); +var sign = require('math-intrinsics/sign'); + +var $Function = Function; + +// eslint-disable-next-line consistent-return +var getEvalledConstructor = function (expressionSyntax) { + try { + return $Function('"use strict"; return (' + expressionSyntax + ').constructor;')(); + } catch (e) {} +}; + +var $gOPD = require('gopd'); +var $defineProperty = require('es-define-property'); + +var throwTypeError = function () { + throw new $TypeError(); +}; +var ThrowTypeError = $gOPD + ? (function () { + try { + // eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties + arguments.callee; // IE 8 does not throw here + return throwTypeError; + } catch (calleeThrows) { + try { + // IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '') + return $gOPD(arguments, 'callee').get; + } catch (gOPDthrows) { + return throwTypeError; + } + } + }()) + : throwTypeError; + +var hasSymbols = require('has-symbols')(); + +var getProto = require('get-proto'); +var $ObjectGPO = require('get-proto/Object.getPrototypeOf'); +var $ReflectGPO = require('get-proto/Reflect.getPrototypeOf'); + +var $apply = require('call-bind-apply-helpers/functionApply'); +var $call = require('call-bind-apply-helpers/functionCall'); + +var needsEval = {}; + +var TypedArray = typeof Uint8Array === 'undefined' || !getProto ? undefined : getProto(Uint8Array); + +var INTRINSICS = { + __proto__: null, + '%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError, + '%Array%': Array, + '%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer, + '%ArrayIteratorPrototype%': hasSymbols && getProto ? getProto([][Symbol.iterator]()) : undefined, + '%AsyncFromSyncIteratorPrototype%': undefined, + '%AsyncFunction%': needsEval, + '%AsyncGenerator%': needsEval, + '%AsyncGeneratorFunction%': needsEval, + '%AsyncIteratorPrototype%': needsEval, + '%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics, + '%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt, + '%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array, + '%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array, + '%Boolean%': Boolean, + '%DataView%': typeof DataView === 'undefined' ? undefined : DataView, + '%Date%': Date, + '%decodeURI%': decodeURI, + '%decodeURIComponent%': decodeURIComponent, + '%encodeURI%': encodeURI, + '%encodeURIComponent%': encodeURIComponent, + '%Error%': $Error, + '%eval%': eval, // eslint-disable-line no-eval + '%EvalError%': $EvalError, + '%Float16Array%': typeof Float16Array === 'undefined' ? undefined : Float16Array, + '%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array, + '%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array, + '%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry, + '%Function%': $Function, + '%GeneratorFunction%': needsEval, + '%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array, + '%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array, + '%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array, + '%isFinite%': isFinite, + '%isNaN%': isNaN, + '%IteratorPrototype%': hasSymbols && getProto ? getProto(getProto([][Symbol.iterator]())) : undefined, + '%JSON%': typeof JSON === 'object' ? JSON : undefined, + '%Map%': typeof Map === 'undefined' ? undefined : Map, + '%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Map()[Symbol.iterator]()), + '%Math%': Math, + '%Number%': Number, + '%Object%': $Object, + '%Object.getOwnPropertyDescriptor%': $gOPD, + '%parseFloat%': parseFloat, + '%parseInt%': parseInt, + '%Promise%': typeof Promise === 'undefined' ? undefined : Promise, + '%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy, + '%RangeError%': $RangeError, + '%ReferenceError%': $ReferenceError, + '%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect, + '%RegExp%': RegExp, + '%Set%': typeof Set === 'undefined' ? undefined : Set, + '%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols || !getProto ? undefined : getProto(new Set()[Symbol.iterator]()), + '%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer, + '%String%': String, + '%StringIteratorPrototype%': hasSymbols && getProto ? getProto(''[Symbol.iterator]()) : undefined, + '%Symbol%': hasSymbols ? Symbol : undefined, + '%SyntaxError%': $SyntaxError, + '%ThrowTypeError%': ThrowTypeError, + '%TypedArray%': TypedArray, + '%TypeError%': $TypeError, + '%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array, + '%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray, + '%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array, + '%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array, + '%URIError%': $URIError, + '%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap, + '%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef, + '%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet, + + '%Function.prototype.call%': $call, + '%Function.prototype.apply%': $apply, + '%Object.defineProperty%': $defineProperty, + '%Object.getPrototypeOf%': $ObjectGPO, + '%Math.abs%': abs, + '%Math.floor%': floor, + '%Math.max%': max, + '%Math.min%': min, + '%Math.pow%': pow, + '%Math.round%': round, + '%Math.sign%': sign, + '%Reflect.getPrototypeOf%': $ReflectGPO +}; + +if (getProto) { + try { + null.error; // eslint-disable-line no-unused-expressions + } catch (e) { + // https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229 + var errorProto = getProto(getProto(e)); + INTRINSICS['%Error.prototype%'] = errorProto; + } +} + +var doEval = function doEval(name) { + var value; + if (name === '%AsyncFunction%') { + value = getEvalledConstructor('async function () {}'); + } else if (name === '%GeneratorFunction%') { + value = getEvalledConstructor('function* () {}'); + } else if (name === '%AsyncGeneratorFunction%') { + value = getEvalledConstructor('async function* () {}'); + } else if (name === '%AsyncGenerator%') { + var fn = doEval('%AsyncGeneratorFunction%'); + if (fn) { + value = fn.prototype; + } + } else if (name === '%AsyncIteratorPrototype%') { + var gen = doEval('%AsyncGenerator%'); + if (gen && getProto) { + value = getProto(gen.prototype); + } + } + + INTRINSICS[name] = value; + + return value; +}; + +var LEGACY_ALIASES = { + __proto__: null, + '%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'], + '%ArrayPrototype%': ['Array', 'prototype'], + '%ArrayProto_entries%': ['Array', 'prototype', 'entries'], + '%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'], + '%ArrayProto_keys%': ['Array', 'prototype', 'keys'], + '%ArrayProto_values%': ['Array', 'prototype', 'values'], + '%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'], + '%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'], + '%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'], + '%BooleanPrototype%': ['Boolean', 'prototype'], + '%DataViewPrototype%': ['DataView', 'prototype'], + '%DatePrototype%': ['Date', 'prototype'], + '%ErrorPrototype%': ['Error', 'prototype'], + '%EvalErrorPrototype%': ['EvalError', 'prototype'], + '%Float32ArrayPrototype%': ['Float32Array', 'prototype'], + '%Float64ArrayPrototype%': ['Float64Array', 'prototype'], + '%FunctionPrototype%': ['Function', 'prototype'], + '%Generator%': ['GeneratorFunction', 'prototype'], + '%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'], + '%Int8ArrayPrototype%': ['Int8Array', 'prototype'], + '%Int16ArrayPrototype%': ['Int16Array', 'prototype'], + '%Int32ArrayPrototype%': ['Int32Array', 'prototype'], + '%JSONParse%': ['JSON', 'parse'], + '%JSONStringify%': ['JSON', 'stringify'], + '%MapPrototype%': ['Map', 'prototype'], + '%NumberPrototype%': ['Number', 'prototype'], + '%ObjectPrototype%': ['Object', 'prototype'], + '%ObjProto_toString%': ['Object', 'prototype', 'toString'], + '%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'], + '%PromisePrototype%': ['Promise', 'prototype'], + '%PromiseProto_then%': ['Promise', 'prototype', 'then'], + '%Promise_all%': ['Promise', 'all'], + '%Promise_reject%': ['Promise', 'reject'], + '%Promise_resolve%': ['Promise', 'resolve'], + '%RangeErrorPrototype%': ['RangeError', 'prototype'], + '%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'], + '%RegExpPrototype%': ['RegExp', 'prototype'], + '%SetPrototype%': ['Set', 'prototype'], + '%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'], + '%StringPrototype%': ['String', 'prototype'], + '%SymbolPrototype%': ['Symbol', 'prototype'], + '%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'], + '%TypedArrayPrototype%': ['TypedArray', 'prototype'], + '%TypeErrorPrototype%': ['TypeError', 'prototype'], + '%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'], + '%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'], + '%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'], + '%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'], + '%URIErrorPrototype%': ['URIError', 'prototype'], + '%WeakMapPrototype%': ['WeakMap', 'prototype'], + '%WeakSetPrototype%': ['WeakSet', 'prototype'] +}; + +var bind = require('function-bind'); +var hasOwn = require('hasown'); +var $concat = bind.call($call, Array.prototype.concat); +var $spliceApply = bind.call($apply, Array.prototype.splice); +var $replace = bind.call($call, String.prototype.replace); +var $strSlice = bind.call($call, String.prototype.slice); +var $exec = bind.call($call, RegExp.prototype.exec); + +/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */ +var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g; +var reEscapeChar = /\\(\\)?/g; /** Used to match backslashes in property paths. */ +var stringToPath = function stringToPath(string) { + var first = $strSlice(string, 0, 1); + var last = $strSlice(string, -1); + if (first === '%' && last !== '%') { + throw new $SyntaxError('invalid intrinsic syntax, expected closing `%`'); + } else if (last === '%' && first !== '%') { + throw new $SyntaxError('invalid intrinsic syntax, expected opening `%`'); + } + var result = []; + $replace(string, rePropName, function (match, number, quote, subString) { + result[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match; + }); + return result; +}; +/* end adaptation */ + +var getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) { + var intrinsicName = name; + var alias; + if (hasOwn(LEGACY_ALIASES, intrinsicName)) { + alias = LEGACY_ALIASES[intrinsicName]; + intrinsicName = '%' + alias[0] + '%'; + } + + if (hasOwn(INTRINSICS, intrinsicName)) { + var value = INTRINSICS[intrinsicName]; + if (value === needsEval) { + value = doEval(intrinsicName); + } + if (typeof value === 'undefined' && !allowMissing) { + throw new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!'); + } + + return { + alias: alias, + name: intrinsicName, + value: value + }; + } + + throw new $SyntaxError('intrinsic ' + name + ' does not exist!'); +}; + +module.exports = function GetIntrinsic(name, allowMissing) { + if (typeof name !== 'string' || name.length === 0) { + throw new $TypeError('intrinsic name must be a non-empty string'); + } + if (arguments.length > 1 && typeof allowMissing !== 'boolean') { + throw new $TypeError('"allowMissing" argument must be a boolean'); + } + + if ($exec(/^%?[^%]*%?$/, name) === null) { + throw new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name'); + } + var parts = stringToPath(name); + var intrinsicBaseName = parts.length > 0 ? parts[0] : ''; + + var intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing); + var intrinsicRealName = intrinsic.name; + var value = intrinsic.value; + var skipFurtherCaching = false; + + var alias = intrinsic.alias; + if (alias) { + intrinsicBaseName = alias[0]; + $spliceApply(parts, $concat([0, 1], alias)); + } + + for (var i = 1, isOwn = true; i < parts.length; i += 1) { + var part = parts[i]; + var first = $strSlice(part, 0, 1); + var last = $strSlice(part, -1); + if ( + ( + (first === '"' || first === "'" || first === '`') + || (last === '"' || last === "'" || last === '`') + ) + && first !== last + ) { + throw new $SyntaxError('property names with quotes must have matching quotes'); + } + if (part === 'constructor' || !isOwn) { + skipFurtherCaching = true; + } + + intrinsicBaseName += '.' + part; + intrinsicRealName = '%' + intrinsicBaseName + '%'; + + if (hasOwn(INTRINSICS, intrinsicRealName)) { + value = INTRINSICS[intrinsicRealName]; + } else if (value != null) { + if (!(part in value)) { + if (!allowMissing) { + throw new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.'); + } + return void undefined; + } + if ($gOPD && (i + 1) >= parts.length) { + var desc = $gOPD(value, part); + isOwn = !!desc; + + // By convention, when a data property is converted to an accessor + // property to emulate a data property that does not suffer from + // the override mistake, that accessor's getter is marked with + // an `originalValue` property. Here, when we detect this, we + // uphold the illusion by pretending to see that original data + // property, i.e., returning the value rather than the getter + // itself. + if (isOwn && 'get' in desc && !('originalValue' in desc.get)) { + value = desc.get; + } else { + value = value[part]; + } + } else { + isOwn = hasOwn(value, part); + value = value[part]; + } + + if (isOwn && !skipFurtherCaching) { + INTRINSICS[intrinsicRealName] = value; + } + } + } + return value; +}; diff --git a/tools/ui/node_modules/get-intrinsic/package.json b/tools/ui/node_modules/get-intrinsic/package.json new file mode 100644 index 0000000000000000000000000000000000000000..2828e736c2c67960628ff7ad82e69bb778f2242c --- /dev/null +++ b/tools/ui/node_modules/get-intrinsic/package.json @@ -0,0 +1,97 @@ +{ + "name": "get-intrinsic", + "version": "1.3.0", + "description": "Get and robustly cache all JS language-level intrinsics at first require time", + "main": "index.js", + "exports": { + ".": "./index.js", + "./package.json": "./package.json" + }, + "sideEffects": false, + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepublishOnly": "safe-publish-latest", + "prelint": "evalmd README.md", + "lint": "eslint --ext=.js,.mjs .", + "pretest": "npm run lint", + "tests-only": "nyc tape 'test/**/*.js'", + "test": "npm run tests-only", + "posttest": "npx npm@'>= 10.2' audit --production", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/ljharb/get-intrinsic.git" + }, + "keywords": [ + "javascript", + "ecmascript", + "es", + "js", + "intrinsic", + "getintrinsic", + "es-abstract" + ], + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/ljharb/get-intrinsic/issues" + }, + "homepage": "https://github.com/ljharb/get-intrinsic#readme", + "dependencies": { + "call-bind-apply-helpers": "^1.0.2", + "es-define-property": "^1.0.1", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.1.1", + "function-bind": "^1.1.2", + "get-proto": "^1.0.1", + "gopd": "^1.2.0", + "has-symbols": "^1.1.0", + "hasown": "^2.0.2", + "math-intrinsics": "^1.1.0" + }, + "devDependencies": { + "@ljharb/eslint-config": "^21.1.1", + "auto-changelog": "^2.5.0", + "call-bound": "^1.0.3", + "encoding": "^0.1.13", + "es-abstract": "^1.23.9", + "es-value-fixtures": "^1.7.1", + "eslint": "=8.8.0", + "evalmd": "^0.0.19", + "for-each": "^0.3.5", + "make-async-function": "^1.0.0", + "make-async-generator-function": "^1.0.0", + "make-generator-function": "^2.0.0", + "mock-property": "^1.1.0", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "object-inspect": "^1.13.4", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "testling": { + "files": "test/GetIntrinsic.js" + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + }, + "engines": { + "node": ">= 0.4" + } +} diff --git a/tools/ui/node_modules/get-intrinsic/test/GetIntrinsic.js b/tools/ui/node_modules/get-intrinsic/test/GetIntrinsic.js new file mode 100644 index 0000000000000000000000000000000000000000..d9c0f30a34ccccdf1636aa599b7d40dc7d111e5e --- /dev/null +++ b/tools/ui/node_modules/get-intrinsic/test/GetIntrinsic.js @@ -0,0 +1,274 @@ +'use strict'; + +var GetIntrinsic = require('../'); + +var test = require('tape'); +var forEach = require('for-each'); +var debug = require('object-inspect'); +var generatorFns = require('make-generator-function')(); +var asyncFns = require('make-async-function').list(); +var asyncGenFns = require('make-async-generator-function')(); +var mockProperty = require('mock-property'); + +var callBound = require('call-bound'); +var v = require('es-value-fixtures'); +var $gOPD = require('gopd'); +var DefinePropertyOrThrow = require('es-abstract/2023/DefinePropertyOrThrow'); + +var $isProto = callBound('%Object.prototype.isPrototypeOf%'); + +test('export', function (t) { + t.equal(typeof GetIntrinsic, 'function', 'it is a function'); + t.equal(GetIntrinsic.length, 2, 'function has length of 2'); + + t.end(); +}); + +test('throws', function (t) { + t['throws']( + function () { GetIntrinsic('not an intrinsic'); }, + SyntaxError, + 'nonexistent intrinsic throws a syntax error' + ); + + t['throws']( + function () { GetIntrinsic(''); }, + TypeError, + 'empty string intrinsic throws a type error' + ); + + t['throws']( + function () { GetIntrinsic('.'); }, + SyntaxError, + '"just a dot" intrinsic throws a syntax error' + ); + + t['throws']( + function () { GetIntrinsic('%String'); }, + SyntaxError, + 'Leading % without trailing % throws a syntax error' + ); + + t['throws']( + function () { GetIntrinsic('String%'); }, + SyntaxError, + 'Trailing % without leading % throws a syntax error' + ); + + t['throws']( + function () { GetIntrinsic("String['prototype]"); }, + SyntaxError, + 'Dynamic property access is disallowed for intrinsics (unterminated string)' + ); + + t['throws']( + function () { GetIntrinsic('%Proxy.prototype.undefined%'); }, + TypeError, + "Throws when middle part doesn't exist (%Proxy.prototype.undefined%)" + ); + + t['throws']( + function () { GetIntrinsic('%Array.prototype%garbage%'); }, + SyntaxError, + 'Throws with extra percent signs' + ); + + t['throws']( + function () { GetIntrinsic('%Array.prototype%push%'); }, + SyntaxError, + 'Throws with extra percent signs, even on an existing intrinsic' + ); + + forEach(v.nonStrings, function (nonString) { + t['throws']( + function () { GetIntrinsic(nonString); }, + TypeError, + debug(nonString) + ' is not a String' + ); + }); + + forEach(v.nonBooleans, function (nonBoolean) { + t['throws']( + function () { GetIntrinsic('%', nonBoolean); }, + TypeError, + debug(nonBoolean) + ' is not a Boolean' + ); + }); + + forEach([ + 'toString', + 'propertyIsEnumerable', + 'hasOwnProperty' + ], function (objectProtoMember) { + t['throws']( + function () { GetIntrinsic(objectProtoMember); }, + SyntaxError, + debug(objectProtoMember) + ' is not an intrinsic' + ); + }); + + t.end(); +}); + +test('base intrinsics', function (t) { + t.equal(GetIntrinsic('%Object%'), Object, '%Object% yields Object'); + t.equal(GetIntrinsic('Object'), Object, 'Object yields Object'); + t.equal(GetIntrinsic('%Array%'), Array, '%Array% yields Array'); + t.equal(GetIntrinsic('Array'), Array, 'Array yields Array'); + + t.end(); +}); + +test('dotted paths', function (t) { + t.equal(GetIntrinsic('%Object.prototype.toString%'), Object.prototype.toString, '%Object.prototype.toString% yields Object.prototype.toString'); + t.equal(GetIntrinsic('Object.prototype.toString'), Object.prototype.toString, 'Object.prototype.toString yields Object.prototype.toString'); + t.equal(GetIntrinsic('%Array.prototype.push%'), Array.prototype.push, '%Array.prototype.push% yields Array.prototype.push'); + t.equal(GetIntrinsic('Array.prototype.push'), Array.prototype.push, 'Array.prototype.push yields Array.prototype.push'); + + test('underscore paths are aliases for dotted paths', { skip: !Object.isFrozen || Object.isFrozen(Object.prototype) }, function (st) { + var original = GetIntrinsic('%ObjProto_toString%'); + + forEach([ + '%Object.prototype.toString%', + 'Object.prototype.toString', + '%ObjectPrototype.toString%', + 'ObjectPrototype.toString', + '%ObjProto_toString%', + 'ObjProto_toString' + ], function (name) { + DefinePropertyOrThrow(Object.prototype, 'toString', { + '[[Value]]': function toString() { + return original.apply(this, arguments); + } + }); + st.equal(GetIntrinsic(name), original, name + ' yields original Object.prototype.toString'); + }); + + DefinePropertyOrThrow(Object.prototype, 'toString', { '[[Value]]': original }); + st.end(); + }); + + test('dotted paths cache', { skip: !Object.isFrozen || Object.isFrozen(Object.prototype) }, function (st) { + var original = GetIntrinsic('%Object.prototype.propertyIsEnumerable%'); + + forEach([ + '%Object.prototype.propertyIsEnumerable%', + 'Object.prototype.propertyIsEnumerable', + '%ObjectPrototype.propertyIsEnumerable%', + 'ObjectPrototype.propertyIsEnumerable' + ], function (name) { + var restore = mockProperty(Object.prototype, 'propertyIsEnumerable', { + value: function propertyIsEnumerable() { + return original.apply(this, arguments); + } + }); + st.equal(GetIntrinsic(name), original, name + ' yields cached Object.prototype.propertyIsEnumerable'); + + restore(); + }); + + st.end(); + }); + + test('dotted path reports correct error', function (st) { + st['throws'](function () { + GetIntrinsic('%NonExistentIntrinsic.prototype.property%'); + }, /%NonExistentIntrinsic%/, 'The base intrinsic of %NonExistentIntrinsic.prototype.property% is %NonExistentIntrinsic%'); + + st['throws'](function () { + GetIntrinsic('%NonExistentIntrinsicPrototype.property%'); + }, /%NonExistentIntrinsicPrototype%/, 'The base intrinsic of %NonExistentIntrinsicPrototype.property% is %NonExistentIntrinsicPrototype%'); + + st.end(); + }); + + t.end(); +}); + +test('accessors', { skip: !$gOPD || typeof Map !== 'function' }, function (t) { + var actual = $gOPD(Map.prototype, 'size'); + t.ok(actual, 'Map.prototype.size has a descriptor'); + t.equal(typeof actual.get, 'function', 'Map.prototype.size has a getter function'); + t.equal(GetIntrinsic('%Map.prototype.size%'), actual.get, '%Map.prototype.size% yields the getter for it'); + t.equal(GetIntrinsic('Map.prototype.size'), actual.get, 'Map.prototype.size yields the getter for it'); + + t.end(); +}); + +test('generator functions', { skip: !generatorFns.length }, function (t) { + var $GeneratorFunction = GetIntrinsic('%GeneratorFunction%'); + var $GeneratorFunctionPrototype = GetIntrinsic('%Generator%'); + var $GeneratorPrototype = GetIntrinsic('%GeneratorPrototype%'); + + forEach(generatorFns, function (genFn) { + var fnName = genFn.name; + fnName = fnName ? "'" + fnName + "'" : 'genFn'; + + t.ok(genFn instanceof $GeneratorFunction, fnName + ' instanceof %GeneratorFunction%'); + t.ok($isProto($GeneratorFunctionPrototype, genFn), '%Generator% is prototype of ' + fnName); + t.ok($isProto($GeneratorPrototype, genFn.prototype), '%GeneratorPrototype% is prototype of ' + fnName + '.prototype'); + }); + + t.end(); +}); + +test('async functions', { skip: !asyncFns.length }, function (t) { + var $AsyncFunction = GetIntrinsic('%AsyncFunction%'); + var $AsyncFunctionPrototype = GetIntrinsic('%AsyncFunctionPrototype%'); + + forEach(asyncFns, function (asyncFn) { + var fnName = asyncFn.name; + fnName = fnName ? "'" + fnName + "'" : 'asyncFn'; + + t.ok(asyncFn instanceof $AsyncFunction, fnName + ' instanceof %AsyncFunction%'); + t.ok($isProto($AsyncFunctionPrototype, asyncFn), '%AsyncFunctionPrototype% is prototype of ' + fnName); + }); + + t.end(); +}); + +test('async generator functions', { skip: asyncGenFns.length === 0 }, function (t) { + var $AsyncGeneratorFunction = GetIntrinsic('%AsyncGeneratorFunction%'); + var $AsyncGeneratorFunctionPrototype = GetIntrinsic('%AsyncGenerator%'); + var $AsyncGeneratorPrototype = GetIntrinsic('%AsyncGeneratorPrototype%'); + + forEach(asyncGenFns, function (asyncGenFn) { + var fnName = asyncGenFn.name; + fnName = fnName ? "'" + fnName + "'" : 'asyncGenFn'; + + t.ok(asyncGenFn instanceof $AsyncGeneratorFunction, fnName + ' instanceof %AsyncGeneratorFunction%'); + t.ok($isProto($AsyncGeneratorFunctionPrototype, asyncGenFn), '%AsyncGenerator% is prototype of ' + fnName); + t.ok($isProto($AsyncGeneratorPrototype, asyncGenFn.prototype), '%AsyncGeneratorPrototype% is prototype of ' + fnName + '.prototype'); + }); + + t.end(); +}); + +test('%ThrowTypeError%', function (t) { + var $ThrowTypeError = GetIntrinsic('%ThrowTypeError%'); + + t.equal(typeof $ThrowTypeError, 'function', 'is a function'); + t['throws']( + $ThrowTypeError, + TypeError, + '%ThrowTypeError% throws a TypeError' + ); + + t.end(); +}); + +test('allowMissing', { skip: asyncGenFns.length > 0 }, function (t) { + t['throws']( + function () { GetIntrinsic('%AsyncGeneratorPrototype%'); }, + TypeError, + 'throws when missing' + ); + + t.equal( + GetIntrinsic('%AsyncGeneratorPrototype%', true), + undefined, + 'does not throw when allowMissing' + ); + + t.end(); +}); diff --git a/tools/ui/node_modules/get-own-enumerable-property-symbols/CHANGELOG.md b/tools/ui/node_modules/get-own-enumerable-property-symbols/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..20328150621a956cf90fc151ffbabdc093e3f427 --- /dev/null +++ b/tools/ui/node_modules/get-own-enumerable-property-symbols/CHANGELOG.md @@ -0,0 +1,12 @@ +# Changelog + +All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines. + +### [3.0.2](https://github.com/mightyiam/get-own-enumerable-property-symbols/compare/v3.0.1...v3.0.2) (2019-12-10) + + +### Bug Fixes + +* add missing license file ([dbf11c2](https://github.com/mightyiam/get-own-enumerable-property-symbols/commit/dbf11c2b705dcfb42d6ac291f6608adb14ed6fd3)), closes [#87](https://github.com/mightyiam/get-own-enumerable-property-symbols/issues/87) + +### [3.0.1](https://github.com/mightyiam/get-own-enumerable-property-symbols/compare/v3.0.0...v3.0.1) (2019-10-04) diff --git a/tools/ui/node_modules/get-own-enumerable-property-symbols/LICENSE b/tools/ui/node_modules/get-own-enumerable-property-symbols/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..e5e73f8b6b048ae368047fab1d88841059662e13 --- /dev/null +++ b/tools/ui/node_modules/get-own-enumerable-property-symbols/LICENSE @@ -0,0 +1,13 @@ +Copyright (c) 2019, Shahar Or + +Permission to use, copy, modify, and/or distribute this software for any purpose +with or without fee is hereby granted, provided that the above copyright notice +and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS +OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +THIS SOFTWARE. \ No newline at end of file diff --git a/tools/ui/node_modules/get-own-enumerable-property-symbols/README.md b/tools/ui/node_modules/get-own-enumerable-property-symbols/README.md new file mode 100644 index 0000000000000000000000000000000000000000..63f25fd19918826906ba67034f44344443d154c0 --- /dev/null +++ b/tools/ui/node_modules/get-own-enumerable-property-symbols/README.md @@ -0,0 +1,15 @@ +# get-own-enumerable-property-symbols [![Build Status](https://travis-ci.org/mightyiam/get-own-enumerable-property-symbols.svg?branch=master)](https://travis-ci.org/mightyiam/get-own-enumerable-property-symbols) + +Returns an array of all *enumerable* symbol properties found directly upon a given object. + +Similar to [`Object.getOwnPropertySymbols`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySymbols) +but only [enumerable](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties) keys. + +```js +import getOwnEnumPropSymbols from 'get-own-enumerable-property-symbols' + +getOwnEnumPropSymbols({ [Symbol()]: undefined }) +// [Symbol()] +getOwnEnumPropSymbols(Object.defineProperty({}, Symbol(), {enumerable: false})) +// [] +``` diff --git a/tools/ui/node_modules/get-own-enumerable-property-symbols/lib/index.d.ts b/tools/ui/node_modules/get-own-enumerable-property-symbols/lib/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..dc51e643986074fbb433cbba5ca9a67825d26bba --- /dev/null +++ b/tools/ui/node_modules/get-own-enumerable-property-symbols/lib/index.d.ts @@ -0,0 +1,2 @@ +declare const _default: (object: object) => symbol[]; +export default _default; diff --git a/tools/ui/node_modules/get-own-enumerable-property-symbols/lib/index.js b/tools/ui/node_modules/get-own-enumerable-property-symbols/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..4f16a349eb44c17857b0193508d6303f1f730047 --- /dev/null +++ b/tools/ui/node_modules/get-own-enumerable-property-symbols/lib/index.js @@ -0,0 +1,6 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.default = (object) => Object + .getOwnPropertySymbols(object) + .filter((keySymbol) => Object.prototype.propertyIsEnumerable.call(object, keySymbol)); +//# sourceMappingURL=index.js.map \ No newline at end of file diff --git a/tools/ui/node_modules/get-own-enumerable-property-symbols/lib/index.js.map b/tools/ui/node_modules/get-own-enumerable-property-symbols/lib/index.js.map new file mode 100644 index 0000000000000000000000000000000000000000..81cad199164f2e06ee156346e23db129f7297496 --- /dev/null +++ b/tools/ui/node_modules/get-own-enumerable-property-symbols/lib/index.js.map @@ -0,0 +1 @@ +{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;AAAA,kBAAe,CAAC,MAAc,EAAY,EAAE,CAAC,MAAM;KAChD,qBAAqB,CAAC,MAAM,CAAC;KAC7B,MAAM,CAAC,CAAC,SAAS,EAAW,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAA"} \ No newline at end of file diff --git a/tools/ui/node_modules/get-own-enumerable-property-symbols/package.json b/tools/ui/node_modules/get-own-enumerable-property-symbols/package.json new file mode 100644 index 0000000000000000000000000000000000000000..3b85d008fcf495ee505551df07122027b46ae32c --- /dev/null +++ b/tools/ui/node_modules/get-own-enumerable-property-symbols/package.json @@ -0,0 +1,69 @@ +{ + "name": "get-own-enumerable-property-symbols", + "version": "3.0.2", + "description": "Returns an array of all enumerable symbol properties found directly upon a given object", + "main": "lib/index.js", + "types": "lib/index.d.ts", + "files": [ + "lib/index.d.ts", + "lib/index.js", + "lib/index.js.map" + ], + "scripts": { + "release": "standard-version", + "lint": "eslint --ext .ts .", + "transpile": "tsc", + "unit": "node lib/test.js", + "test": "run-s lint transpile unit" + }, + "standard": { + "ignore": [ + "lib" + ] + }, + "repository": { + "type": "git", + "url": "git+https://github.com/mightyiam/get-own-enumerable-property-symbols.git" + }, + "keywords": [ + "get", + "enumerable", + "symbol", + "property", + "key", + "object" + ], + "author": "Shahar Or (mightyiam)", + "license": "ISC", + "bugs": { + "url": "https://github.com/mightyiam/get-own-enumerable-property-symbols/issues" + }, + "husky": { + "hooks": { + "commit-msg": "commitlint -E HUSKY_GIT_PARAMS", + "pre-commit": "npm test" + } + }, + "homepage": "https://github.com/mightyiam/get-own-enumerable-property-symbols#readme", + "devDependencies": { + "@commitlint/cli": "^8.2.0", + "@commitlint/config-conventional": "^8.2.0", + "@commitlint/travis-cli": "^8.2.0", + "@types/node": "^12.12.11", + "@typescript-eslint/eslint-plugin": "^2.8.0", + "eslint": "^6.6.0", + "eslint-config-standard-with-typescript": "^11.0.1", + "eslint-plugin-import": "^2.18.2", + "eslint-plugin-node": "^10.0.0", + "eslint-plugin-promise": "^4.2.1", + "eslint-plugin-standard": "^4.0.1", + "husky": "^3.1.0", + "npm-run-all": "^4.1.5", + "standard-version": "^7.0.1", + "tsconfigs": "^4.0.1", + "typescript": "^3.7.2" + }, + "eslintIgnore": [ + "*.d.ts" + ] +} diff --git a/tools/ui/node_modules/get-proto/.eslintrc b/tools/ui/node_modules/get-proto/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..1d21a8aefa405581c2fe7e1a1e28bde05a45f1cc --- /dev/null +++ b/tools/ui/node_modules/get-proto/.eslintrc @@ -0,0 +1,10 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "id-length": "off", + "sort-keys": "off", + }, +} diff --git a/tools/ui/node_modules/get-proto/.github/FUNDING.yml b/tools/ui/node_modules/get-proto/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..93183ef5f0448585d4fe09742be017a2a1f857e9 --- /dev/null +++ b/tools/ui/node_modules/get-proto/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/get-proto +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/get-proto/.nycrc b/tools/ui/node_modules/get-proto/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..bdd626ce91477abbdd489b79988baebadbd3c897 --- /dev/null +++ b/tools/ui/node_modules/get-proto/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/get-proto/CHANGELOG.md b/tools/ui/node_modules/get-proto/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..586022936c59d39d5cd280a281f4ffc6fad932f5 --- /dev/null +++ b/tools/ui/node_modules/get-proto/CHANGELOG.md @@ -0,0 +1,21 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.0.1](https://github.com/ljharb/get-proto/compare/v1.0.0...v1.0.1) - 2025-01-02 + +### Commits + +- [Fix] for the `Object.getPrototypeOf` window, throw for non-objects [`7fe6508`](https://github.com/ljharb/get-proto/commit/7fe6508b71419ebe1976bedb86001d1feaeaa49a) + +## v1.0.0 - 2025-01-01 + +### Commits + +- Initial implementation, tests, readme, types [`5c70775`](https://github.com/ljharb/get-proto/commit/5c707751e81c3deeb2cf980d185fc7fd43611415) +- Initial commit [`7c65c2a`](https://github.com/ljharb/get-proto/commit/7c65c2ad4e33d5dae2f219ebe1a046ae2256972c) +- npm init [`0b8cf82`](https://github.com/ljharb/get-proto/commit/0b8cf824c9634e4a34ef7dd2a2cdc5be6ac79518) +- Only apps should have lockfiles [`a6d1bff`](https://github.com/ljharb/get-proto/commit/a6d1bffc364f5828377cea7194558b2dbef7aea2) diff --git a/tools/ui/node_modules/get-proto/LICENSE b/tools/ui/node_modules/get-proto/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..eeabd1c37ce03aeba427120b80997db32513f35f --- /dev/null +++ b/tools/ui/node_modules/get-proto/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 Jordan Harband + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/get-proto/Object.getPrototypeOf.d.ts b/tools/ui/node_modules/get-proto/Object.getPrototypeOf.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..028b3ff1ce7490110b79ec5bf688abd66a8d86dc --- /dev/null +++ b/tools/ui/node_modules/get-proto/Object.getPrototypeOf.d.ts @@ -0,0 +1,5 @@ +declare function getProto(object: O): object | null; + +declare const x: typeof getProto | null; + +export = x; \ No newline at end of file diff --git a/tools/ui/node_modules/get-proto/Object.getPrototypeOf.js b/tools/ui/node_modules/get-proto/Object.getPrototypeOf.js new file mode 100644 index 0000000000000000000000000000000000000000..c2cbbdfc65c390afc3205f87dd95bc996e24cbb8 --- /dev/null +++ b/tools/ui/node_modules/get-proto/Object.getPrototypeOf.js @@ -0,0 +1,6 @@ +'use strict'; + +var $Object = require('es-object-atoms'); + +/** @type {import('./Object.getPrototypeOf')} */ +module.exports = $Object.getPrototypeOf || null; diff --git a/tools/ui/node_modules/get-proto/README.md b/tools/ui/node_modules/get-proto/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f8b4cce347f6718bd564f2d5f9f31f93e17fe5d5 --- /dev/null +++ b/tools/ui/node_modules/get-proto/README.md @@ -0,0 +1,50 @@ +# get-proto [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +Robustly get the [[Prototype]] of an object. Uses the best available method. + +## Getting started + +```sh +npm install --save get-proto +``` + +## Usage/Examples + +```js +const assert = require('assert'); +const getProto = require('get-proto'); + +const a = { a: 1, b: 2, [Symbol.toStringTag]: 'foo' }; +const b = { c: 3, __proto__: a }; + +assert.equal(getProto(b), a); +assert.equal(getProto(a), Object.prototype); +assert.equal(getProto({ __proto__: null }), null); +``` + +## Tests + +Clone the repo, `npm install`, and run `npm test` + +[package-url]: https://npmjs.org/package/get-proto +[npm-version-svg]: https://versionbadg.es/ljharb/get-proto.svg +[deps-svg]: https://david-dm.org/ljharb/get-proto.svg +[deps-url]: https://david-dm.org/ljharb/get-proto +[dev-deps-svg]: https://david-dm.org/ljharb/get-proto/dev-status.svg +[dev-deps-url]: https://david-dm.org/ljharb/get-proto#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/get-proto.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/get-proto.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/get-proto.svg +[downloads-url]: https://npm-stat.com/charts.html?package=get-proto +[codecov-image]: https://codecov.io/gh/ljharb/get-proto/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/ljharb/get-proto/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/ljharb/get-proto +[actions-url]: https://github.com/ljharb/get-proto/actions diff --git a/tools/ui/node_modules/get-proto/Reflect.getPrototypeOf.d.ts b/tools/ui/node_modules/get-proto/Reflect.getPrototypeOf.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2388fe073e3b830f05169d685566e8283d7f3805 --- /dev/null +++ b/tools/ui/node_modules/get-proto/Reflect.getPrototypeOf.d.ts @@ -0,0 +1,3 @@ +declare const x: typeof Reflect.getPrototypeOf | null; + +export = x; \ No newline at end of file diff --git a/tools/ui/node_modules/get-proto/Reflect.getPrototypeOf.js b/tools/ui/node_modules/get-proto/Reflect.getPrototypeOf.js new file mode 100644 index 0000000000000000000000000000000000000000..e6c51bee433645af0221f124bc33e7d7ca3626a6 --- /dev/null +++ b/tools/ui/node_modules/get-proto/Reflect.getPrototypeOf.js @@ -0,0 +1,4 @@ +'use strict'; + +/** @type {import('./Reflect.getPrototypeOf')} */ +module.exports = (typeof Reflect !== 'undefined' && Reflect.getPrototypeOf) || null; diff --git a/tools/ui/node_modules/get-proto/index.d.ts b/tools/ui/node_modules/get-proto/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2c021f304e712d18e77b08d5dd9f87d0bc241021 --- /dev/null +++ b/tools/ui/node_modules/get-proto/index.d.ts @@ -0,0 +1,5 @@ +declare function getProto(object: O): object | null; + +declare const x: typeof getProto | null; + +export = x; diff --git a/tools/ui/node_modules/get-proto/index.js b/tools/ui/node_modules/get-proto/index.js new file mode 100644 index 0000000000000000000000000000000000000000..7e5747be023988fb560d4fc0098e82b8197df340 --- /dev/null +++ b/tools/ui/node_modules/get-proto/index.js @@ -0,0 +1,27 @@ +'use strict'; + +var reflectGetProto = require('./Reflect.getPrototypeOf'); +var originalGetProto = require('./Object.getPrototypeOf'); + +var getDunderProto = require('dunder-proto/get'); + +/** @type {import('.')} */ +module.exports = reflectGetProto + ? function getProto(O) { + // @ts-expect-error TS can't narrow inside a closure, for some reason + return reflectGetProto(O); + } + : originalGetProto + ? function getProto(O) { + if (!O || (typeof O !== 'object' && typeof O !== 'function')) { + throw new TypeError('getProto: not an object'); + } + // @ts-expect-error TS can't narrow inside a closure, for some reason + return originalGetProto(O); + } + : getDunderProto + ? function getProto(O) { + // @ts-expect-error TS can't narrow inside a closure, for some reason + return getDunderProto(O); + } + : null; diff --git a/tools/ui/node_modules/get-proto/package.json b/tools/ui/node_modules/get-proto/package.json new file mode 100644 index 0000000000000000000000000000000000000000..9c35cec93a5697a6c0858b8bbf8092c9dcca27ee --- /dev/null +++ b/tools/ui/node_modules/get-proto/package.json @@ -0,0 +1,81 @@ +{ + "name": "get-proto", + "version": "1.0.1", + "description": "Robustly get the [[Prototype]] of an object", + "main": "index.js", + "exports": { + ".": "./index.js", + "./Reflect.getPrototypeOf": "./Reflect.getPrototypeOf.js", + "./Object.getPrototypeOf": "./Object.getPrototypeOf.js", + "./package.json": "./package.json" + }, + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepublishOnly": "safe-publish-latest", + "pretest": "npm run --silent lint", + "test": "npm run tests-only", + "posttest": "npx npm@\">=10.2\" audit --production", + "tests-only": "nyc tape 'test/**/*.js'", + "prelint": "evalmd README.md", + "lint": "eslint --ext=js,mjs .", + "postlint": "tsc && attw -P", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/ljharb/get-proto.git" + }, + "keywords": [ + "get", + "proto", + "prototype", + "getPrototypeOf", + "[[Prototype]]" + ], + "author": "Jordan Harband ", + "license": "MIT", + "bugs": { + "url": "https://github.com/ljharb/get-proto/issues" + }, + "homepage": "https://github.com/ljharb/get-proto#readme", + "dependencies": { + "dunder-proto": "^1.0.1", + "es-object-atoms": "^1.0.0" + }, + "devDependencies": { + "@arethetypeswrong/cli": "^0.17.2", + "@ljharb/eslint-config": "^21.1.1", + "@ljharb/tsconfig": "^0.2.3", + "@types/tape": "^5.8.0", + "auto-changelog": "^2.5.0", + "eslint": "=8.8.0", + "evalmd": "^0.0.19", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0", + "typescript": "next" + }, + "engines": { + "node": ">= 0.4" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + }, + "testling": { + "files": "test/index.js" + } +} diff --git a/tools/ui/node_modules/get-proto/test/index.js b/tools/ui/node_modules/get-proto/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..5a2ece252d1aaa7f2bc64e7eb958278a42c944dc --- /dev/null +++ b/tools/ui/node_modules/get-proto/test/index.js @@ -0,0 +1,68 @@ +'use strict'; + +var test = require('tape'); + +var getProto = require('../'); + +test('getProto', function (t) { + t.equal(typeof getProto, 'function', 'is a function'); + + t.test('can get', { skip: !getProto }, function (st) { + if (getProto) { // TS doesn't understand tape's skip + var proto = { b: 2 }; + st.equal(getProto(proto), Object.prototype, 'proto: returns the [[Prototype]]'); + + st.test('nullish value', function (s2t) { + // @ts-expect-error + s2t['throws'](function () { return getProto(undefined); }, TypeError, 'undefined is not an object'); + // @ts-expect-error + s2t['throws'](function () { return getProto(null); }, TypeError, 'null is not an object'); + s2t.end(); + }); + + // @ts-expect-error + st['throws'](function () { getProto(true); }, 'throws for true'); + // @ts-expect-error + st['throws'](function () { getProto(false); }, 'throws for false'); + // @ts-expect-error + st['throws'](function () { getProto(42); }, 'throws for 42'); + // @ts-expect-error + st['throws'](function () { getProto(NaN); }, 'throws for NaN'); + // @ts-expect-error + st['throws'](function () { getProto(0); }, 'throws for +0'); + // @ts-expect-error + st['throws'](function () { getProto(-0); }, 'throws for -0'); + // @ts-expect-error + st['throws'](function () { getProto(Infinity); }, 'throws for ∞'); + // @ts-expect-error + st['throws'](function () { getProto(-Infinity); }, 'throws for -∞'); + // @ts-expect-error + st['throws'](function () { getProto(''); }, 'throws for empty string'); + // @ts-expect-error + st['throws'](function () { getProto('foo'); }, 'throws for non-empty string'); + st.equal(getProto(/a/g), RegExp.prototype); + st.equal(getProto(new Date()), Date.prototype); + st.equal(getProto(function () {}), Function.prototype); + st.equal(getProto([]), Array.prototype); + st.equal(getProto({}), Object.prototype); + + var nullObject = { __proto__: null }; + if ('toString' in nullObject) { + st.comment('no null objects in this engine'); + st.equal(getProto(nullObject), Object.prototype, '"null" object has Object.prototype as [[Prototype]]'); + } else { + st.equal(getProto(nullObject), null, 'null object has null [[Prototype]]'); + } + } + + st.end(); + }); + + t.test('can not get', { skip: !!getProto }, function (st) { + st.equal(getProto, null); + + st.end(); + }); + + t.end(); +}); diff --git a/tools/ui/node_modules/get-proto/tsconfig.json b/tools/ui/node_modules/get-proto/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..60fb90e45970d491a68e6db8c72fcc531d13a44e --- /dev/null +++ b/tools/ui/node_modules/get-proto/tsconfig.json @@ -0,0 +1,9 @@ +{ + "extends": "@ljharb/tsconfig", + "compilerOptions": { + //"target": "es2021", + }, + "exclude": [ + "coverage", + ], +} diff --git a/tools/ui/node_modules/get-symbol-description/.eslintrc b/tools/ui/node_modules/get-symbol-description/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..e824dabcc490f8da5414292c8f1df4d8513f520e --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/.eslintrc @@ -0,0 +1,14 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "id-length": 0, + "new-cap": [2, { + "capIsNewExceptions": [ + "GetIntrinsic", + ], + }], + }, +} diff --git a/tools/ui/node_modules/get-symbol-description/.github/FUNDING.yml b/tools/ui/node_modules/get-symbol-description/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..a25dc10af283f7687e8e0fd21a3182ad5c1a43ce --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/get-symbol-description +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/get-symbol-description/.nycrc b/tools/ui/node_modules/get-symbol-description/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..bdd626ce91477abbdd489b79988baebadbd3c897 --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/get-symbol-description/CHANGELOG.md b/tools/ui/node_modules/get-symbol-description/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..ba03100b0c73a108d6d872313bc9bfa593ac52cf --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/CHANGELOG.md @@ -0,0 +1,61 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.1.0](https://github.com/inspect-js/get-symbol-description/compare/v1.0.2...v1.1.0) - 2024-12-17 + +### Commits + +- [New] add types [`b957b65`](https://github.com/inspect-js/get-symbol-description/commit/b957b65e08bc1a6ac95fa5ab769ec241b9cac885) +- [actions] split out node 10-20, and 20+ [`bfbcae2`](https://github.com/inspect-js/get-symbol-description/commit/bfbcae2ab7224fcf4328bc139ba79445d64030a6) +- [Dev Deps] update `@ljharb/eslint-config`, `auto-changelog`, `es-value-fixtures`, `object-inspect`, tape` [`197ba80`](https://github.com/inspect-js/get-symbol-description/commit/197ba80ef87153e28f20ec353e8b926ddb145da0) +- [Refactor] use `call-bound` directly [`9df4de4`](https://github.com/inspect-js/get-symbol-description/commit/9df4de4e8faae09e84c5ac97ec22b4f010d03fca) +- [Deps] update `call-bind`, `get-intrinsic` [`44c1400`](https://github.com/inspect-js/get-symbol-description/commit/44c1400d5088429f6a32a5f81628d9f7270f68ca) +- [Dev Deps] update `hasown`, `tape` [`44e2264`](https://github.com/inspect-js/get-symbol-description/commit/44e226470a83e89523bb4898e1ef7a0942e6cb3a) +- [Tests] replace `aud` with `npm audit` [`62d9414`](https://github.com/inspect-js/get-symbol-description/commit/62d9414d316f7ba2320cb6fad8d9fd4d8b99c420) +- [Deps] update `call-bind` [`396ee27`](https://github.com/inspect-js/get-symbol-description/commit/396ee2763238415c51eec62fbc41bf274c6552b2) +- [Dev Deps] add missing peer dep [`cc4b9eb`](https://github.com/inspect-js/get-symbol-description/commit/cc4b9eb527504a49e91f560ee6d9cb942db4e46f) + +## [v1.0.2](https://github.com/inspect-js/get-symbol-description/compare/v1.0.1...v1.0.2) - 2024-02-07 + +### Fixed + +- [Deps] add missing `get-intrinsic` [`#3`](https://github.com/inspect-js/get-symbol-description/issues/3) + +## [v1.0.1](https://github.com/inspect-js/get-symbol-description/compare/v1.0.0...v1.0.1) - 2024-02-05 + +### Commits + +- [actions] reuse common workflows [`168adf2`](https://github.com/inspect-js/get-symbol-description/commit/168adf213f86e5c69a93b4768a20ad543a70b231) +- [meta] use `npmignore` to autogenerate an npmignore file [`fa3b323`](https://github.com/inspect-js/get-symbol-description/commit/fa3b323f0605cf966a5cef1a103ada46d63e466b) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `es-value-fixtures`, `foreach`, `object-inspect`, `tape` [`9301b9e`](https://github.com/inspect-js/get-symbol-description/commit/9301b9e274fd9b7544af3d7d437dd254e83095e0) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `object-inspect`, `tape` [`a92a011`](https://github.com/inspect-js/get-symbol-description/commit/a92a0119f373fb61c58e3eb1d5fb6b3a3f66f157) +- [actions] update rebase action to use reusable workflow [`66cea29`](https://github.com/inspect-js/get-symbol-description/commit/66cea29835bc88ab5e937ccf996ea96409475a0e) +- [actions] update codecov uploader [`84079e1`](https://github.com/inspect-js/get-symbol-description/commit/84079e12e1421a79b63757cc3ab9c599e8eecc75) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `object-inspect`, `safe-publish-latest`, `tape` [`9f298a5`](https://github.com/inspect-js/get-symbol-description/commit/9f298a521e6f8a9b974b6b95e0b3de8aeaf74d9c) +- [Dev Deps] use `hasown` instead of `has` [`e993bd6`](https://github.com/inspect-js/get-symbol-description/commit/e993bd62a08a1adc2f75664be99a36e031ecf604) +- [Dev Deps] update `aud`, `npmignore`, `tape` [`5044bed`](https://github.com/inspect-js/get-symbol-description/commit/5044bed49a1b2b529b0c92fee0504747fda78147) +- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `tape` [`3923eab`](https://github.com/inspect-js/get-symbol-description/commit/3923eabcf3eb2ddad7dbfd542102c29646dac242) +- [Refactor] use `es-errors`, so things that only need those do not need `get-intrinsic` [`a24f5c5`](https://github.com/inspect-js/get-symbol-description/commit/a24f5c5f6ddd1f24b22ecdc2546eb9b06924f62a) +- [Deps] update `call-bind`, `get-intrinsic` [`accd484`](https://github.com/inspect-js/get-symbol-description/commit/accd484cb970c11fb39eb5ec4301572fa4043e37) +- [Dev Deps] update `object-inspect`, `tape` [`6c66623`](https://github.com/inspect-js/get-symbol-description/commit/6c666237114333bcb548e2c9ba6eb4924cb154ad) +- [Dev Deps] update `object-inspect`, `tape` [`586dfe3`](https://github.com/inspect-js/get-symbol-description/commit/586dfe35b9b6e7dba3fb7577c5973b7466d101a3) +- [Dev Deps] update `@ljharb/eslint-config`, `aud` [`bc8c7e0`](https://github.com/inspect-js/get-symbol-description/commit/bc8c7e0382682164f78b87f41764a0a2e389c435) +- [Tests] use `for-each` instead of `foreach` [`ca97918`](https://github.com/inspect-js/get-symbol-description/commit/ca97918eaad4ff1df11fd6f187da60227722dfcd) +- [Robustness] cache String slice [`5ce0c56`](https://github.com/inspect-js/get-symbol-description/commit/5ce0c5658224ed5cf5c6775a18ee2ad60c5b7ba8) +- [Deps] update `get-intrinsic` [`b656c5c`](https://github.com/inspect-js/get-symbol-description/commit/b656c5c68fbeec35d75a635ca991b61ed004bf54) +- [Deps] update `get-intrinsic` [`74cf3b6`](https://github.com/inspect-js/get-symbol-description/commit/74cf3b6525c49998f2c984d350e4d59d7f70794c) +- [meta] fix FUNDING.yml [`6cf76c8`](https://github.com/inspect-js/get-symbol-description/commit/6cf76c8c56bf366f767a84e82038db54b508641a) + +## v1.0.0 - 2021-08-17 + +### Commits + +- Initial commit: pulled from es-abstract [`6e34a05`](https://github.com/inspect-js/get-symbol-description/commit/6e34a05ef10ce8620078cf4cecbe276c1fc1ae77) +- Initial commit [`3862092`](https://github.com/inspect-js/get-symbol-description/commit/3862092248d8ffa071ec90ec39d73e8be14ba6f1) +- [meta] do not publish github action workflow files [`9d1e2b9`](https://github.com/inspect-js/get-symbol-description/commit/9d1e2b94dd97664da5d0666985a3695c23f45865) +- npm init [`5051b32`](https://github.com/inspect-js/get-symbol-description/commit/5051b3221829f364c44b4d5e9a0c35aab3247f6a) +- Only apps should have lockfiles [`b866d1c`](https://github.com/inspect-js/get-symbol-description/commit/b866d1c4b4029277618d968cfb3cbe00f012d1a7) diff --git a/tools/ui/node_modules/get-symbol-description/LICENSE b/tools/ui/node_modules/get-symbol-description/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..7948bc02a7937478ae009ff3796e76b25bdfbb08 --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Inspect JS + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/get-symbol-description/README.md b/tools/ui/node_modules/get-symbol-description/README.md new file mode 100644 index 0000000000000000000000000000000000000000..c44e72aa17f08f91e20fb209535517cb2b0f9fbc --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/README.md @@ -0,0 +1,43 @@ +# get-symbol-description [![Version Badge][2]][1] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![dependency status][5]][6] +[![dev dependency status][7]][8] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][11]][1] + +Gets the description of a Symbol. Handles `Symbol()` vs `Symbol('')` properly when possible. + +## Example + +```js +var getSymbolDescription = require('get-symbol-description'); +var assert = require('assert'); + +assert(getSymbolDescription(Symbol()) === undefined); +assert(getSymbolDescription(Symbol('')) === ''); // or `undefined`, if in an engine that lacks name inference from concise method +assert(getSymbolDescription(Symbol('foo')) === 'foo'); +assert(getSymbolDescription(Symbol.iterator) === 'Symbol.iterator'); +``` + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[1]: https://npmjs.org/package/get-symbol-description +[2]: https://versionbadg.es/inspect-js/get-symbol-description.svg +[5]: https://david-dm.org/inspect-js/get-symbol-description.svg +[6]: https://david-dm.org/inspect-js/get-symbol-description +[7]: https://david-dm.org/inspect-js/get-symbol-description/dev-status.svg +[8]: https://david-dm.org/inspect-js/get-symbol-description#info=devDependencies +[11]: https://nodei.co/npm/get-symbol-description.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/get-symbol-description.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/get-symbol-description.svg +[downloads-url]: https://npm-stat.com/charts.html?package=get-symbol-description +[codecov-image]: https://codecov.io/gh/inspect-js/get-symbol-description/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/inspect-js/get-symbol-description/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/get-symbol-description +[actions-url]: https://github.com/inspect-js/get-symbol-description/actions diff --git a/tools/ui/node_modules/get-symbol-description/getInferredName.d.ts b/tools/ui/node_modules/get-symbol-description/getInferredName.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..6aa12d2a5e60017159c0dc57c332980283db3990 --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/getInferredName.d.ts @@ -0,0 +1,5 @@ +declare function getInferredName(key: PropertyKey): string; + +declare const x: typeof getInferredName | undefined | null; + +export = x; \ No newline at end of file diff --git a/tools/ui/node_modules/get-symbol-description/getInferredName.js b/tools/ui/node_modules/get-symbol-description/getInferredName.js new file mode 100644 index 0000000000000000000000000000000000000000..5949f695903c7d902577714e8f67b94abcb5cb7b --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/getInferredName.js @@ -0,0 +1,13 @@ +'use strict'; + +/** @type {NonNullable | undefined} */ +var getInferredName; +try { + // eslint-disable-next-line no-new-func, no-extra-parens + getInferredName = /** @type {NonNullable} */ (Function('s', 'return { [s]() {} }[s].name;')); +} catch (e) {} + +var inferred = function () {}; + +/** @type {import('./getInferredName')} */ +module.exports = getInferredName && inferred.name === 'inferred' ? getInferredName : null; diff --git a/tools/ui/node_modules/get-symbol-description/index.d.ts b/tools/ui/node_modules/get-symbol-description/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..14d54afa7b7ef92db503401ecc1f322736a4d53c --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/index.d.ts @@ -0,0 +1,3 @@ +declare function getSymbolDescription(thisArg: symbol | Symbol): string | undefined; + +export = getSymbolDescription; \ No newline at end of file diff --git a/tools/ui/node_modules/get-symbol-description/index.js b/tools/ui/node_modules/get-symbol-description/index.js new file mode 100644 index 0000000000000000000000000000000000000000..13d150329d4794f1719091c9c3166d4b3a59ed8f --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/index.js @@ -0,0 +1,49 @@ +'use strict'; + +var GetIntrinsic = require('get-intrinsic'); + +var callBound = require('call-bound'); + +var $SyntaxError = require('es-errors/syntax'); +var getGlobalSymbolDescription = GetIntrinsic('%Symbol.keyFor%', true); +/** @type {undefined | ((thisArg: symbol | Symbol) => symbol)} */ +var thisSymbolValue = callBound('%Symbol.prototype.valueOf%', true); +/** @type {undefined | ((thisArg: symbol | Symbol) => string)} */ +var symToStr = callBound('Symbol.prototype.toString', true); +/** @type {(thisArg: string, start?: number, end?: number) => string} */ +var $strSlice = callBound('String.prototype.slice'); + +var getInferredName = require('./getInferredName'); + +/** @type {import('.')} */ +/* eslint-disable consistent-return */ +module.exports = callBound('%Symbol.prototype.description%', true) || function getSymbolDescription(symbol) { + if (!thisSymbolValue) { + throw new $SyntaxError('Symbols are not supported in this environment'); + } + + // will throw if not a symbol primitive or wrapper object + var sym = thisSymbolValue(symbol); + + if (getInferredName) { + var name = getInferredName(sym); + if (name === '') { + return; + } + return name.slice(1, -1); // name.slice('['.length, -']'.length); + } + + var desc; + if (getGlobalSymbolDescription) { + desc = getGlobalSymbolDescription(sym); + if (typeof desc === 'string') { + return desc; + } + } + + // eslint-disable-next-line no-extra-parens + desc = $strSlice(/** @type {NonNullable} */ (symToStr)(sym), 7, -1); // str.slice('Symbol('.length, -')'.length); + if (desc) { + return desc; + } +}; diff --git a/tools/ui/node_modules/get-symbol-description/package.json b/tools/ui/node_modules/get-symbol-description/package.json new file mode 100644 index 0000000000000000000000000000000000000000..63050c213d6f7bb797018799801bc0b1696f2ae9 --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/package.json @@ -0,0 +1,88 @@ +{ + "name": "get-symbol-description", + "version": "1.1.0", + "description": "Gets the description of a Symbol. Handles `Symbol()` vs `Symbol('')` properly when possible.", + "main": "index.js", + "exports": { + ".": "./index.js", + "./getInferredName": "./getInferredName.js", + "./package.json": "./package.json" + }, + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepublishOnly": "safe-publish-latest", + "prelint": "evalmd README.md", + "lint": "eslint --ext=.js,.mjs .", + "postlint": "tsc && attw -P", + "pretest": "npm run lint", + "tests-only": "nyc tape 'test/**/*.js'", + "test": "npm run tests-only", + "posttest": "npx npm@'>= 10.2' audit --production", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/inspect-js/get-symbol-description.git" + }, + "keywords": [ + "symbol", + "ecmascript", + "javascript", + "description" + ], + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/inspect-js/get-symbol-description/issues" + }, + "homepage": "https://github.com/inspect-js/get-symbol-description#readme", + "dependencies": { + "call-bound": "^1.0.3", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.6" + }, + "devDependencies": { + "@arethetypeswrong/cli": "^0.17.1", + "@ljharb/eslint-config": "^21.1.1", + "@ljharb/tsconfig": "^0.2.2", + "@types/for-each": "^0.3.3", + "@types/get-intrinsic": "^1.2.3", + "@types/object-inspect": "^1.13.0", + "@types/tape": "^5.7.0", + "auto-changelog": "^2.5.0", + "encoding": "^0.1.13", + "es-value-fixtures": "^1.5.0", + "eslint": "=8.8.0", + "evalmd": "^0.0.19", + "for-each": "^0.3.3", + "hasown": "^2.0.2", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "object-inspect": "^1.13.3", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0", + "typescript": "^5.8.0-dev.20241216" + }, + "engines": { + "node": ">= 0.4" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + } +} diff --git a/tools/ui/node_modules/get-symbol-description/test/index.js b/tools/ui/node_modules/get-symbol-description/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..3d0375cf2fae146cd7f1208f05965a213e42654b --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/test/index.js @@ -0,0 +1,74 @@ +'use strict'; + +var test = require('tape'); +var debug = require('object-inspect'); +var forEach = require('for-each'); +var hasOwn = require('hasown'); +var v = require('es-value-fixtures'); + +var getSymbolDescription = require('../'); +var getInferredName = require('../getInferredName'); + +test('getSymbolDescription', function (t) { + t.test('no symbols', { skip: v.hasSymbols }, function (st) { + st['throws']( + // @ts-expect-error + getSymbolDescription, + SyntaxError, + 'requires Symbol support' + ); + + st.end(); + }); + + forEach([].concat( + // @ts-expect-error TS sucks with concat + v.nonSymbolPrimitives, + v.objects + ), function (nonSymbol) { + t['throws']( + function () { getSymbolDescription(nonSymbol); }, + v.hasSymbols ? TypeError : SyntaxError, + debug(nonSymbol) + ' is not a Symbol' + ); + }); + + t.test('with symbols', { skip: !v.hasSymbols }, function (st) { + forEach( + // eslint-disable-next-line no-extra-parens + /** @type {[symbol, undefined | string][]} */ ([ + [Symbol(), undefined], + [Symbol(undefined), undefined], + // @ts-expect-error + [Symbol(null), 'null'], + [Symbol.iterator, 'Symbol.iterator'], + [Symbol('foo'), 'foo'] + ]), + function (pair) { + var sym = pair[0]; + var desc = pair[1]; + st.equal(getSymbolDescription(sym), desc, debug(sym) + ' description is ' + debug(desc)); + } + ); + + st.test('only possible when inference or native `Symbol.prototype.description` is supported', { + skip: !getInferredName && !hasOwn(Symbol.prototype, 'description') + }, function (s2t) { + s2t.equal(getSymbolDescription(Symbol('')), '', 'Symbol("") description is ""'); + + s2t.end(); + }); + + st.test('only possible when global symbols are supported', { + skip: !hasOwn(Symbol, 'for') || !hasOwn(Symbol, 'keyFor') + }, function (s2t) { + // eslint-disable-next-line no-restricted-properties + s2t.equal(getSymbolDescription(Symbol['for']('')), '', 'Symbol.for("") description is ""'); + s2t.end(); + }); + + st.end(); + }); + + t.end(); +}); diff --git a/tools/ui/node_modules/get-symbol-description/tsconfig.json b/tools/ui/node_modules/get-symbol-description/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..dabbe230d74beb5962f67a6da7da18c707441ad5 --- /dev/null +++ b/tools/ui/node_modules/get-symbol-description/tsconfig.json @@ -0,0 +1,9 @@ +{ + "extends": "@ljharb/tsconfig", + "compilerOptions": { + "target": "ES2021", + }, + "exclude": [ + "coverage", + ], +} diff --git a/tools/ui/node_modules/glob-parent/LICENSE b/tools/ui/node_modules/glob-parent/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..d701b08324fac71d4da754bbceee539b402b4623 --- /dev/null +++ b/tools/ui/node_modules/glob-parent/LICENSE @@ -0,0 +1,15 @@ +The ISC License + +Copyright (c) 2015, 2019 Elan Shanker, 2021 Blaine Bublitz , Eric Schoffstall and other contributors + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/tools/ui/node_modules/glob-parent/README.md b/tools/ui/node_modules/glob-parent/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6ae18a1a089e55a3c97e0c719e6ef9c7ffea982e --- /dev/null +++ b/tools/ui/node_modules/glob-parent/README.md @@ -0,0 +1,134 @@ +

+ + + +

+ +# glob-parent + +[![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Build Status][ci-image]][ci-url] [![Coveralls Status][coveralls-image]][coveralls-url] + +Extract the non-magic parent path from a glob string. + +## Usage + +```js +var globParent = require('glob-parent'); + +globParent('path/to/*.js'); // 'path/to' +globParent('/root/path/to/*.js'); // '/root/path/to' +globParent('/*.js'); // '/' +globParent('*.js'); // '.' +globParent('**/*.js'); // '.' +globParent('path/{to,from}'); // 'path' +globParent('path/!(to|from)'); // 'path' +globParent('path/?(to|from)'); // 'path' +globParent('path/+(to|from)'); // 'path' +globParent('path/*(to|from)'); // 'path' +globParent('path/@(to|from)'); // 'path' +globParent('path/**/*'); // 'path' + +// if provided a non-glob path, returns the nearest dir +globParent('path/foo/bar.js'); // 'path/foo' +globParent('path/foo/'); // 'path/foo' +globParent('path/foo'); // 'path' (see issue #3 for details) +``` + +## API + +### `globParent(maybeGlobString, [options])` + +Takes a string and returns the part of the path before the glob begins. Be aware of Escaping rules and Limitations below. + +#### options + +```js +{ + // Disables the automatic conversion of slashes for Windows + flipBackslashes: true; +} +``` + +## Escaping + +The following characters have special significance in glob patterns and must be escaped if you want them to be treated as regular path characters: + +- `?` (question mark) unless used as a path segment alone +- `*` (asterisk) +- `|` (pipe) +- `(` (opening parenthesis) +- `)` (closing parenthesis) +- `{` (opening curly brace) +- `}` (closing curly brace) +- `[` (opening bracket) +- `]` (closing bracket) + +**Example** + +```js +globParent('foo/[bar]/'); // 'foo' +globParent('foo/\\[bar]/'); // 'foo/[bar]' +``` + +## Limitations + +### Braces & Brackets + +This library attempts a quick and imperfect method of determining which path +parts have glob magic without fully parsing/lexing the pattern. There are some +advanced use cases that can trip it up, such as nested braces where the outer +pair is escaped and the inner one contains a path separator. If you find +yourself in the unlikely circumstance of being affected by this or need to +ensure higher-fidelity glob handling in your library, it is recommended that you +pre-process your input with [expand-braces] and/or [expand-brackets]. + +### Windows + +Backslashes are not valid path separators for globs. If a path with backslashes +is provided anyway, for simple cases, glob-parent will replace the path +separator for you and return the non-glob parent path (now with +forward-slashes, which are still valid as Windows path separators). + +This cannot be used in conjunction with escape characters. + +```js +// BAD +globParent('C:\\Program Files \\(x86\\)\\*.ext'); // 'C:/Program Files /(x86/)' + +// GOOD +globParent('C:/Program Files\\(x86\\)/*.ext'); // 'C:/Program Files (x86)' +``` + +If you are using escape characters for a pattern without path parts (i.e. +relative to `cwd`), prefix with `./` to avoid confusing glob-parent. + +```js +// BAD +globParent('foo \\[bar]'); // 'foo ' +globParent('foo \\[bar]*'); // 'foo ' + +// GOOD +globParent('./foo \\[bar]'); // 'foo [bar]' +globParent('./foo \\[bar]*'); // '.' +``` + +## License + +ISC + + +[downloads-image]: https://img.shields.io/npm/dm/glob-parent.svg?style=flat-square +[npm-url]: https://www.npmjs.com/package/glob-parent +[npm-image]: https://img.shields.io/npm/v/glob-parent.svg?style=flat-square + +[ci-url]: https://github.com/gulpjs/glob-parent/actions?query=workflow:dev +[ci-image]: https://img.shields.io/github/workflow/status/gulpjs/glob-parent/dev?style=flat-square + +[coveralls-url]: https://coveralls.io/r/gulpjs/glob-parent +[coveralls-image]: https://img.shields.io/coveralls/gulpjs/glob-parent/master.svg?style=flat-square + + + +[expand-braces]: https://github.com/jonschlinkert/expand-braces +[expand-brackets]: https://github.com/jonschlinkert/expand-brackets + diff --git a/tools/ui/node_modules/glob-parent/index.js b/tools/ui/node_modules/glob-parent/index.js new file mode 100644 index 0000000000000000000000000000000000000000..09dde64ba7c12cbfa38474af10db668d6bfd5a70 --- /dev/null +++ b/tools/ui/node_modules/glob-parent/index.js @@ -0,0 +1,75 @@ +'use strict'; + +var isGlob = require('is-glob'); +var pathPosixDirname = require('path').posix.dirname; +var isWin32 = require('os').platform() === 'win32'; + +var slash = '/'; +var backslash = /\\/g; +var escaped = /\\([!*?|[\](){}])/g; + +/** + * @param {string} str + * @param {Object} opts + * @param {boolean} [opts.flipBackslashes=true] + */ +module.exports = function globParent(str, opts) { + var options = Object.assign({ flipBackslashes: true }, opts); + + // flip windows path separators + if (options.flipBackslashes && isWin32 && str.indexOf(slash) < 0) { + str = str.replace(backslash, slash); + } + + // special case for strings ending in enclosure containing path separator + if (isEnclosure(str)) { + str += slash; + } + + // preserves full path in case of trailing path separator + str += 'a'; + + // remove path parts that are globby + do { + str = pathPosixDirname(str); + } while (isGlobby(str)); + + // remove escape chars and return result + return str.replace(escaped, '$1'); +}; + +function isEnclosure(str) { + var lastChar = str.slice(-1); + + var enclosureStart; + switch (lastChar) { + case '}': + enclosureStart = '{'; + break; + case ']': + enclosureStart = '['; + break; + default: + return false; + } + + var foundIndex = str.indexOf(enclosureStart); + if (foundIndex < 0) { + return false; + } + + return str.slice(foundIndex + 1, -1).includes(slash); +} + +function isGlobby(str) { + if (/\([^()]+$/.test(str)) { + return true; + } + if (str[0] === '{' || str[0] === '[') { + return true; + } + if (/[^\\][{[]/.test(str)) { + return true; + } + return isGlob(str); +} diff --git a/tools/ui/node_modules/glob-parent/package.json b/tools/ui/node_modules/glob-parent/package.json new file mode 100644 index 0000000000000000000000000000000000000000..baeab4217a04fce13604502b17d4fd8cde540b1c --- /dev/null +++ b/tools/ui/node_modules/glob-parent/package.json @@ -0,0 +1,54 @@ +{ + "name": "glob-parent", + "version": "6.0.2", + "description": "Extract the non-magic parent path from a glob string.", + "author": "Gulp Team (https://gulpjs.com/)", + "contributors": [ + "Elan Shanker (https://github.com/es128)", + "Blaine Bublitz " + ], + "repository": "gulpjs/glob-parent", + "license": "ISC", + "engines": { + "node": ">=10.13.0" + }, + "main": "index.js", + "files": [ + "LICENSE", + "index.js" + ], + "scripts": { + "lint": "eslint .", + "pretest": "npm run lint", + "test": "nyc mocha --async-only" + }, + "dependencies": { + "is-glob": "^4.0.3" + }, + "devDependencies": { + "eslint": "^7.0.0", + "eslint-config-gulp": "^5.0.0", + "expect": "^26.0.1", + "mocha": "^7.1.2", + "nyc": "^15.0.1" + }, + "nyc": { + "reporter": [ + "lcov", + "text-summary" + ] + }, + "prettier": { + "singleQuote": true + }, + "keywords": [ + "glob", + "parent", + "strip", + "path", + "dirname", + "directory", + "base", + "wildcard" + ] +} diff --git a/tools/ui/node_modules/globals/globals.json b/tools/ui/node_modules/globals/globals.json new file mode 100644 index 0000000000000000000000000000000000000000..19b82e4ca72f940600cc77c9e2f430a18f81da47 --- /dev/null +++ b/tools/ui/node_modules/globals/globals.json @@ -0,0 +1,3345 @@ +{ + "amd": { + "define": false, + "require": false + }, + "applescript": { + "$": false, + "Application": false, + "Automation": false, + "console": false, + "delay": false, + "Library": false, + "ObjC": false, + "ObjectSpecifier": false, + "Path": false, + "Progress": false, + "Ref": false + }, + "astro": { + "Astro": false + }, + "atomtest": { + "advanceClock": false, + "atom": false, + "fakeClearInterval": false, + "fakeClearTimeout": false, + "fakeSetInterval": false, + "fakeSetTimeout": false, + "resetTimeouts": false, + "waitsForPromise": false + }, + "browser": { + "AbortController": false, + "AbortSignal": false, + "AbsoluteOrientationSensor": false, + "AbstractRange": false, + "Accelerometer": false, + "addEventListener": false, + "ai": false, + "AI": false, + "AICreateMonitor": false, + "AITextSession": false, + "alert": false, + "AnalyserNode": false, + "Animation": false, + "AnimationEffect": false, + "AnimationEvent": false, + "AnimationPlaybackEvent": false, + "AnimationTimeline": false, + "AsyncDisposableStack": false, + "atob": false, + "Attr": false, + "Audio": false, + "AudioBuffer": false, + "AudioBufferSourceNode": false, + "AudioContext": false, + "AudioData": false, + "AudioDecoder": false, + "AudioDestinationNode": false, + "AudioEncoder": false, + "AudioListener": false, + "AudioNode": false, + "AudioParam": false, + "AudioParamMap": false, + "AudioProcessingEvent": false, + "AudioScheduledSourceNode": false, + "AudioSinkInfo": false, + "AudioWorklet": false, + "AudioWorkletGlobalScope": false, + "AudioWorkletNode": false, + "AudioWorkletProcessor": false, + "AuthenticatorAssertionResponse": false, + "AuthenticatorAttestationResponse": false, + "AuthenticatorResponse": false, + "BackgroundFetchManager": false, + "BackgroundFetchRecord": false, + "BackgroundFetchRegistration": false, + "BarcodeDetector": false, + "BarProp": false, + "BaseAudioContext": false, + "BatteryManager": false, + "BeforeUnloadEvent": false, + "BiquadFilterNode": false, + "Blob": false, + "BlobEvent": false, + "Bluetooth": false, + "BluetoothCharacteristicProperties": false, + "BluetoothDevice": false, + "BluetoothRemoteGATTCharacteristic": false, + "BluetoothRemoteGATTDescriptor": false, + "BluetoothRemoteGATTServer": false, + "BluetoothRemoteGATTService": false, + "BluetoothUUID": false, + "blur": false, + "BroadcastChannel": false, + "BrowserCaptureMediaStreamTrack": false, + "btoa": false, + "ByteLengthQueuingStrategy": false, + "Cache": false, + "caches": false, + "CacheStorage": false, + "cancelAnimationFrame": false, + "cancelIdleCallback": false, + "CanvasCaptureMediaStream": false, + "CanvasCaptureMediaStreamTrack": false, + "CanvasGradient": false, + "CanvasPattern": false, + "CanvasRenderingContext2D": false, + "CaptureController": false, + "CaretPosition": false, + "CDATASection": false, + "ChannelMergerNode": false, + "ChannelSplitterNode": false, + "ChapterInformation": false, + "CharacterBoundsUpdateEvent": false, + "CharacterData": false, + "clearInterval": false, + "clearTimeout": false, + "clientInformation": false, + "Clipboard": false, + "ClipboardChangeEvent": false, + "ClipboardEvent": false, + "ClipboardItem": false, + "close": false, + "closed": false, + "CloseEvent": false, + "CloseWatcher": false, + "CommandEvent": false, + "Comment": false, + "CompositionEvent": false, + "CompressionStream": false, + "confirm": false, + "console": false, + "ConstantSourceNode": false, + "ContentVisibilityAutoStateChangeEvent": false, + "ConvolverNode": false, + "CookieChangeEvent": false, + "CookieDeprecationLabel": false, + "cookieStore": false, + "CookieStore": false, + "CookieStoreManager": false, + "CountQueuingStrategy": false, + "createImageBitmap": false, + "CreateMonitor": false, + "Credential": false, + "credentialless": false, + "CredentialsContainer": false, + "CropTarget": false, + "crossOriginIsolated": false, + "crypto": false, + "Crypto": false, + "CryptoKey": false, + "CSPViolationReportBody": false, + "CSS": false, + "CSSAnimation": false, + "CSSConditionRule": false, + "CSSContainerRule": false, + "CSSCounterStyleRule": false, + "CSSFontFaceRule": false, + "CSSFontFeatureValuesRule": false, + "CSSFontPaletteValuesRule": false, + "CSSFunctionDeclarations": false, + "CSSFunctionDescriptors": false, + "CSSFunctionRule": false, + "CSSGroupingRule": false, + "CSSImageValue": false, + "CSSImportRule": false, + "CSSKeyframeRule": false, + "CSSKeyframesRule": false, + "CSSKeywordValue": false, + "CSSLayerBlockRule": false, + "CSSLayerStatementRule": false, + "CSSMarginRule": false, + "CSSMathClamp": false, + "CSSMathInvert": false, + "CSSMathMax": false, + "CSSMathMin": false, + "CSSMathNegate": false, + "CSSMathProduct": false, + "CSSMathSum": false, + "CSSMathValue": false, + "CSSMatrixComponent": false, + "CSSMediaRule": false, + "CSSNamespaceRule": false, + "CSSNestedDeclarations": false, + "CSSNumericArray": false, + "CSSNumericValue": false, + "CSSPageDescriptors": false, + "CSSPageRule": false, + "CSSPerspective": false, + "CSSPositionTryDescriptors": false, + "CSSPositionTryRule": false, + "CSSPositionValue": false, + "CSSPropertyRule": false, + "CSSRotate": false, + "CSSRule": false, + "CSSRuleList": false, + "CSSScale": false, + "CSSScopeRule": false, + "CSSSkew": false, + "CSSSkewX": false, + "CSSSkewY": false, + "CSSStartingStyleRule": false, + "CSSStyleDeclaration": false, + "CSSStyleRule": false, + "CSSStyleSheet": false, + "CSSStyleValue": false, + "CSSSupportsRule": false, + "CSSTransformComponent": false, + "CSSTransformValue": false, + "CSSTransition": false, + "CSSTranslate": false, + "CSSUnitValue": false, + "CSSUnparsedValue": false, + "CSSVariableReferenceValue": false, + "CSSViewTransitionRule": false, + "currentFrame": false, + "currentTime": false, + "CustomElementRegistry": false, + "customElements": false, + "CustomEvent": false, + "CustomStateSet": false, + "DataTransfer": false, + "DataTransferItem": false, + "DataTransferItemList": false, + "DecompressionStream": false, + "DelayNode": false, + "DelegatedInkTrailPresenter": false, + "DeviceMotionEvent": false, + "DeviceMotionEventAcceleration": false, + "DeviceMotionEventRotationRate": false, + "DeviceOrientationEvent": false, + "devicePixelRatio": false, + "DevicePosture": false, + "DigitalCredential": false, + "dispatchEvent": false, + "DisposableStack": false, + "document": false, + "Document": false, + "DocumentFragment": false, + "documentPictureInPicture": false, + "DocumentPictureInPicture": false, + "DocumentPictureInPictureEvent": false, + "DocumentTimeline": false, + "DocumentType": false, + "DOMError": false, + "DOMException": false, + "DOMImplementation": false, + "DOMMatrix": false, + "DOMMatrixReadOnly": false, + "DOMParser": false, + "DOMPoint": false, + "DOMPointReadOnly": false, + "DOMQuad": false, + "DOMRect": false, + "DOMRectList": false, + "DOMRectReadOnly": false, + "DOMStringList": false, + "DOMStringMap": false, + "DOMTokenList": false, + "DragEvent": false, + "DynamicsCompressorNode": false, + "EditContext": false, + "Element": false, + "ElementInternals": false, + "EncodedAudioChunk": false, + "EncodedVideoChunk": false, + "ErrorEvent": false, + "event": false, + "Event": false, + "EventCounts": false, + "EventSource": false, + "EventTarget": false, + "external": false, + "External": false, + "EyeDropper": false, + "FeaturePolicy": false, + "FederatedCredential": false, + "fence": false, + "Fence": false, + "FencedFrameConfig": false, + "fetch": false, + "fetchLater": false, + "FetchLaterResult": false, + "File": false, + "FileList": false, + "FileReader": false, + "FileSystem": false, + "FileSystemDirectoryEntry": false, + "FileSystemDirectoryHandle": false, + "FileSystemDirectoryReader": false, + "FileSystemEntry": false, + "FileSystemFileEntry": false, + "FileSystemFileHandle": false, + "FileSystemHandle": false, + "FileSystemObserver": false, + "FileSystemWritableFileStream": false, + "find": false, + "focus": false, + "FocusEvent": false, + "FontData": false, + "FontFace": false, + "FontFaceSet": false, + "FontFaceSetLoadEvent": false, + "FormData": false, + "FormDataEvent": false, + "FragmentDirective": false, + "frameElement": false, + "frames": false, + "GainNode": false, + "Gamepad": false, + "GamepadAxisMoveEvent": false, + "GamepadButton": false, + "GamepadButtonEvent": false, + "GamepadEvent": false, + "GamepadHapticActuator": false, + "GamepadPose": false, + "Geolocation": false, + "GeolocationCoordinates": false, + "GeolocationPosition": false, + "GeolocationPositionError": false, + "getComputedStyle": false, + "getScreenDetails": false, + "getSelection": false, + "GPU": false, + "GPUAdapter": false, + "GPUAdapterInfo": false, + "GPUBindGroup": false, + "GPUBindGroupLayout": false, + "GPUBuffer": false, + "GPUBufferUsage": false, + "GPUCanvasContext": false, + "GPUColorWrite": false, + "GPUCommandBuffer": false, + "GPUCommandEncoder": false, + "GPUCompilationInfo": false, + "GPUCompilationMessage": false, + "GPUComputePassEncoder": false, + "GPUComputePipeline": false, + "GPUDevice": false, + "GPUDeviceLostInfo": false, + "GPUError": false, + "GPUExternalTexture": false, + "GPUInternalError": false, + "GPUMapMode": false, + "GPUOutOfMemoryError": false, + "GPUPipelineError": false, + "GPUPipelineLayout": false, + "GPUQuerySet": false, + "GPUQueue": false, + "GPURenderBundle": false, + "GPURenderBundleEncoder": false, + "GPURenderPassEncoder": false, + "GPURenderPipeline": false, + "GPUSampler": false, + "GPUShaderModule": false, + "GPUShaderStage": false, + "GPUSupportedFeatures": false, + "GPUSupportedLimits": false, + "GPUTexture": false, + "GPUTextureUsage": false, + "GPUTextureView": false, + "GPUUncapturedErrorEvent": false, + "GPUValidationError": false, + "GravitySensor": false, + "Gyroscope": false, + "HashChangeEvent": false, + "Headers": false, + "HID": false, + "HIDConnectionEvent": false, + "HIDDevice": false, + "HIDInputReportEvent": false, + "Highlight": false, + "HighlightRegistry": false, + "history": false, + "History": false, + "HTMLAllCollection": false, + "HTMLAnchorElement": false, + "HTMLAreaElement": false, + "HTMLAudioElement": false, + "HTMLBaseElement": false, + "HTMLBodyElement": false, + "HTMLBRElement": false, + "HTMLButtonElement": false, + "HTMLCanvasElement": false, + "HTMLCollection": false, + "HTMLDataElement": false, + "HTMLDataListElement": false, + "HTMLDetailsElement": false, + "HTMLDialogElement": false, + "HTMLDirectoryElement": false, + "HTMLDivElement": false, + "HTMLDListElement": false, + "HTMLDocument": false, + "HTMLElement": false, + "HTMLEmbedElement": false, + "HTMLFencedFrameElement": false, + "HTMLFieldSetElement": false, + "HTMLFontElement": false, + "HTMLFormControlsCollection": false, + "HTMLFormElement": false, + "HTMLFrameElement": false, + "HTMLFrameSetElement": false, + "HTMLHeadElement": false, + "HTMLHeadingElement": false, + "HTMLHRElement": false, + "HTMLHtmlElement": false, + "HTMLIFrameElement": false, + "HTMLImageElement": false, + "HTMLInputElement": false, + "HTMLLabelElement": false, + "HTMLLegendElement": false, + "HTMLLIElement": false, + "HTMLLinkElement": false, + "HTMLMapElement": false, + "HTMLMarqueeElement": false, + "HTMLMediaElement": false, + "HTMLMenuElement": false, + "HTMLMetaElement": false, + "HTMLMeterElement": false, + "HTMLModElement": false, + "HTMLObjectElement": false, + "HTMLOListElement": false, + "HTMLOptGroupElement": false, + "HTMLOptionElement": false, + "HTMLOptionsCollection": false, + "HTMLOutputElement": false, + "HTMLParagraphElement": false, + "HTMLParamElement": false, + "HTMLPictureElement": false, + "HTMLPreElement": false, + "HTMLProgressElement": false, + "HTMLQuoteElement": false, + "HTMLScriptElement": false, + "HTMLSelectedContentElement": false, + "HTMLSelectElement": false, + "HTMLSlotElement": false, + "HTMLSourceElement": false, + "HTMLSpanElement": false, + "HTMLStyleElement": false, + "HTMLTableCaptionElement": false, + "HTMLTableCellElement": false, + "HTMLTableColElement": false, + "HTMLTableElement": false, + "HTMLTableRowElement": false, + "HTMLTableSectionElement": false, + "HTMLTemplateElement": false, + "HTMLTextAreaElement": false, + "HTMLTimeElement": false, + "HTMLTitleElement": false, + "HTMLTrackElement": false, + "HTMLUListElement": false, + "HTMLUnknownElement": false, + "HTMLVideoElement": false, + "IDBCursor": false, + "IDBCursorWithValue": false, + "IDBDatabase": false, + "IDBFactory": false, + "IDBIndex": false, + "IDBKeyRange": false, + "IDBObjectStore": false, + "IDBOpenDBRequest": false, + "IDBRecord": false, + "IDBRequest": false, + "IDBTransaction": false, + "IDBVersionChangeEvent": false, + "IdentityCredential": false, + "IdentityCredentialError": false, + "IdentityProvider": false, + "IdleDeadline": false, + "IdleDetector": false, + "IIRFilterNode": false, + "Image": false, + "ImageBitmap": false, + "ImageBitmapRenderingContext": false, + "ImageCapture": false, + "ImageData": false, + "ImageDecoder": false, + "ImageTrack": false, + "ImageTrackList": false, + "indexedDB": false, + "Ink": false, + "innerHeight": false, + "innerWidth": false, + "InputDeviceCapabilities": false, + "InputDeviceInfo": false, + "InputEvent": false, + "IntegrityViolationReportBody": false, + "InterestEvent": false, + "IntersectionObserver": false, + "IntersectionObserverEntry": false, + "isSecureContext": false, + "Keyboard": false, + "KeyboardEvent": false, + "KeyboardLayoutMap": false, + "KeyframeEffect": false, + "LanguageDetector": false, + "LargestContentfulPaint": false, + "LaunchParams": false, + "launchQueue": false, + "LaunchQueue": false, + "LayoutShift": false, + "LayoutShiftAttribution": false, + "length": false, + "LinearAccelerationSensor": false, + "localStorage": false, + "location": true, + "Location": false, + "locationbar": false, + "Lock": false, + "LockManager": false, + "matchMedia": false, + "MathMLElement": false, + "MediaCapabilities": false, + "MediaCapabilitiesInfo": false, + "MediaDeviceInfo": false, + "MediaDevices": false, + "MediaElementAudioSourceNode": false, + "MediaEncryptedEvent": false, + "MediaError": false, + "MediaKeyError": false, + "MediaKeyMessageEvent": false, + "MediaKeys": false, + "MediaKeySession": false, + "MediaKeyStatusMap": false, + "MediaKeySystemAccess": false, + "MediaList": false, + "MediaMetadata": false, + "MediaQueryList": false, + "MediaQueryListEvent": false, + "MediaRecorder": false, + "MediaRecorderErrorEvent": false, + "MediaSession": false, + "MediaSource": false, + "MediaSourceHandle": false, + "MediaStream": false, + "MediaStreamAudioDestinationNode": false, + "MediaStreamAudioSourceNode": false, + "MediaStreamEvent": false, + "MediaStreamTrack": false, + "MediaStreamTrackAudioSourceNode": false, + "MediaStreamTrackAudioStats": false, + "MediaStreamTrackEvent": false, + "MediaStreamTrackGenerator": false, + "MediaStreamTrackProcessor": false, + "MediaStreamTrackVideoStats": false, + "menubar": false, + "MessageChannel": false, + "MessageEvent": false, + "MessagePort": false, + "MIDIAccess": false, + "MIDIConnectionEvent": false, + "MIDIInput": false, + "MIDIInputMap": false, + "MIDIMessageEvent": false, + "MIDIOutput": false, + "MIDIOutputMap": false, + "MIDIPort": false, + "MimeType": false, + "MimeTypeArray": false, + "model": false, + "ModelGenericSession": false, + "ModelManager": false, + "MouseEvent": false, + "moveBy": false, + "moveTo": false, + "MutationEvent": false, + "MutationObserver": false, + "MutationRecord": false, + "name": false, + "NamedNodeMap": false, + "NavigateEvent": false, + "navigation": false, + "Navigation": false, + "NavigationActivation": false, + "NavigationCurrentEntryChangeEvent": false, + "NavigationDestination": false, + "NavigationHistoryEntry": false, + "NavigationPrecommitController": false, + "NavigationPreloadManager": false, + "NavigationTransition": false, + "navigator": false, + "Navigator": false, + "NavigatorLogin": false, + "NavigatorManagedData": false, + "NavigatorUAData": false, + "NetworkInformation": false, + "Node": false, + "NodeFilter": false, + "NodeIterator": false, + "NodeList": false, + "Notification": false, + "NotifyPaintEvent": false, + "NotRestoredReasonDetails": false, + "NotRestoredReasons": false, + "Observable": false, + "OfflineAudioCompletionEvent": false, + "OfflineAudioContext": false, + "offscreenBuffering": false, + "OffscreenCanvas": false, + "OffscreenCanvasRenderingContext2D": false, + "onabort": true, + "onafterprint": true, + "onanimationcancel": true, + "onanimationend": true, + "onanimationiteration": true, + "onanimationstart": true, + "onappinstalled": true, + "onauxclick": true, + "onbeforeinput": true, + "onbeforeinstallprompt": true, + "onbeforematch": true, + "onbeforeprint": true, + "onbeforetoggle": true, + "onbeforeunload": true, + "onbeforexrselect": true, + "onblur": true, + "oncancel": true, + "oncanplay": true, + "oncanplaythrough": true, + "onchange": true, + "onclick": true, + "onclose": true, + "oncommand": true, + "oncontentvisibilityautostatechange": true, + "oncontextlost": true, + "oncontextmenu": true, + "oncontextrestored": true, + "oncopy": true, + "oncuechange": true, + "oncut": true, + "ondblclick": true, + "ondevicemotion": true, + "ondeviceorientation": true, + "ondeviceorientationabsolute": true, + "ondrag": true, + "ondragend": true, + "ondragenter": true, + "ondragleave": true, + "ondragover": true, + "ondragstart": true, + "ondrop": true, + "ondurationchange": true, + "onemptied": true, + "onended": true, + "onerror": true, + "onfocus": true, + "onformdata": true, + "ongamepadconnected": true, + "ongamepaddisconnected": true, + "ongotpointercapture": true, + "onhashchange": true, + "oninput": true, + "oninvalid": true, + "onkeydown": true, + "onkeypress": true, + "onkeyup": true, + "onlanguagechange": true, + "onload": true, + "onloadeddata": true, + "onloadedmetadata": true, + "onloadstart": true, + "onlostpointercapture": true, + "onmessage": true, + "onmessageerror": true, + "onmousedown": true, + "onmouseenter": true, + "onmouseleave": true, + "onmousemove": true, + "onmouseout": true, + "onmouseover": true, + "onmouseup": true, + "onmousewheel": true, + "onoffline": true, + "ononline": true, + "onpagehide": true, + "onpagereveal": true, + "onpageshow": true, + "onpageswap": true, + "onpaste": true, + "onpause": true, + "onplay": true, + "onplaying": true, + "onpointercancel": true, + "onpointerdown": true, + "onpointerenter": true, + "onpointerleave": true, + "onpointermove": true, + "onpointerout": true, + "onpointerover": true, + "onpointerrawupdate": true, + "onpointerup": true, + "onpopstate": true, + "onprogress": true, + "onratechange": true, + "onrejectionhandled": true, + "onreset": true, + "onresize": true, + "onscroll": true, + "onscrollend": true, + "onscrollsnapchange": true, + "onscrollsnapchanging": true, + "onsearch": true, + "onsecuritypolicyviolation": true, + "onseeked": true, + "onseeking": true, + "onselect": true, + "onselectionchange": true, + "onselectstart": true, + "onslotchange": true, + "onstalled": true, + "onstorage": true, + "onsubmit": true, + "onsuspend": true, + "ontimeupdate": true, + "ontoggle": true, + "ontransitioncancel": true, + "ontransitionend": true, + "ontransitionrun": true, + "ontransitionstart": true, + "onunhandledrejection": true, + "onunload": true, + "onvolumechange": true, + "onwaiting": true, + "onwheel": true, + "open": false, + "opener": false, + "Option": false, + "OrientationSensor": false, + "origin": false, + "originAgentCluster": false, + "OscillatorNode": false, + "OTPCredential": false, + "outerHeight": false, + "outerWidth": false, + "OverconstrainedError": false, + "PageRevealEvent": false, + "PageSwapEvent": false, + "PageTransitionEvent": false, + "pageXOffset": false, + "pageYOffset": false, + "PannerNode": false, + "parent": false, + "PasswordCredential": false, + "Path2D": false, + "PaymentAddress": false, + "PaymentManager": false, + "PaymentMethodChangeEvent": false, + "PaymentRequest": false, + "PaymentRequestUpdateEvent": false, + "PaymentResponse": false, + "performance": false, + "Performance": false, + "PerformanceElementTiming": false, + "PerformanceEntry": false, + "PerformanceEventTiming": false, + "PerformanceLongAnimationFrameTiming": false, + "PerformanceLongTaskTiming": false, + "PerformanceMark": false, + "PerformanceMeasure": false, + "PerformanceNavigation": false, + "PerformanceNavigationTiming": false, + "PerformanceObserver": false, + "PerformanceObserverEntryList": false, + "PerformancePaintTiming": false, + "PerformanceResourceTiming": false, + "PerformanceScriptTiming": false, + "PerformanceServerTiming": false, + "PerformanceTiming": false, + "PeriodicSyncManager": false, + "PeriodicWave": false, + "Permissions": false, + "PermissionStatus": false, + "PERSISTENT": false, + "personalbar": false, + "PictureInPictureEvent": false, + "PictureInPictureWindow": false, + "Plugin": false, + "PluginArray": false, + "PointerEvent": false, + "PopStateEvent": false, + "postMessage": false, + "Presentation": false, + "PresentationAvailability": false, + "PresentationConnection": false, + "PresentationConnectionAvailableEvent": false, + "PresentationConnectionCloseEvent": false, + "PresentationConnectionList": false, + "PresentationReceiver": false, + "PresentationRequest": false, + "PressureObserver": false, + "PressureRecord": false, + "print": false, + "ProcessingInstruction": false, + "Profiler": false, + "ProgressEvent": false, + "PromiseRejectionEvent": false, + "prompt": false, + "ProtectedAudience": false, + "PublicKeyCredential": false, + "PushManager": false, + "PushSubscription": false, + "PushSubscriptionOptions": false, + "queryLocalFonts": false, + "queueMicrotask": false, + "QuotaExceededError": false, + "RadioNodeList": false, + "Range": false, + "ReadableByteStreamController": false, + "ReadableStream": false, + "ReadableStreamBYOBReader": false, + "ReadableStreamBYOBRequest": false, + "ReadableStreamDefaultController": false, + "ReadableStreamDefaultReader": false, + "registerProcessor": false, + "RelativeOrientationSensor": false, + "RemotePlayback": false, + "removeEventListener": false, + "ReportBody": false, + "reportError": false, + "ReportingObserver": false, + "Request": false, + "requestAnimationFrame": false, + "requestIdleCallback": false, + "resizeBy": false, + "ResizeObserver": false, + "ResizeObserverEntry": false, + "ResizeObserverSize": false, + "resizeTo": false, + "Response": false, + "RestrictionTarget": false, + "RTCCertificate": false, + "RTCDataChannel": false, + "RTCDataChannelEvent": false, + "RTCDtlsTransport": false, + "RTCDTMFSender": false, + "RTCDTMFToneChangeEvent": false, + "RTCEncodedAudioFrame": false, + "RTCEncodedVideoFrame": false, + "RTCError": false, + "RTCErrorEvent": false, + "RTCIceCandidate": false, + "RTCIceTransport": false, + "RTCPeerConnection": false, + "RTCPeerConnectionIceErrorEvent": false, + "RTCPeerConnectionIceEvent": false, + "RTCRtpReceiver": false, + "RTCRtpScriptTransform": false, + "RTCRtpSender": false, + "RTCRtpTransceiver": false, + "RTCSctpTransport": false, + "RTCSessionDescription": false, + "RTCStatsReport": false, + "RTCTrackEvent": false, + "sampleRate": false, + "scheduler": false, + "Scheduler": false, + "Scheduling": false, + "screen": false, + "Screen": false, + "ScreenDetailed": false, + "ScreenDetails": false, + "screenLeft": false, + "ScreenOrientation": false, + "screenTop": false, + "screenX": false, + "screenY": false, + "ScriptProcessorNode": false, + "scroll": false, + "scrollbars": false, + "scrollBy": false, + "ScrollTimeline": false, + "scrollTo": false, + "scrollX": false, + "scrollY": false, + "SecurityPolicyViolationEvent": false, + "Selection": false, + "self": false, + "Sensor": false, + "SensorErrorEvent": false, + "Serial": false, + "SerialPort": false, + "ServiceWorker": false, + "ServiceWorkerContainer": false, + "ServiceWorkerRegistration": false, + "sessionStorage": false, + "setInterval": false, + "setTimeout": false, + "ShadowRoot": false, + "sharedStorage": false, + "SharedStorage": false, + "SharedStorageAppendMethod": false, + "SharedStorageClearMethod": false, + "SharedStorageDeleteMethod": false, + "SharedStorageModifierMethod": false, + "SharedStorageSetMethod": false, + "SharedStorageWorklet": false, + "SharedWorker": false, + "showDirectoryPicker": false, + "showOpenFilePicker": false, + "showSaveFilePicker": false, + "SnapEvent": false, + "SourceBuffer": false, + "SourceBufferList": false, + "SpeechGrammar": false, + "SpeechGrammarList": false, + "SpeechRecognition": false, + "SpeechRecognitionErrorEvent": false, + "SpeechRecognitionEvent": false, + "SpeechRecognitionPhrase": false, + "speechSynthesis": false, + "SpeechSynthesis": false, + "SpeechSynthesisErrorEvent": false, + "SpeechSynthesisEvent": false, + "SpeechSynthesisUtterance": false, + "SpeechSynthesisVoice": false, + "StaticRange": false, + "status": false, + "statusbar": false, + "StereoPannerNode": false, + "stop": false, + "Storage": false, + "StorageBucket": false, + "StorageBucketManager": false, + "StorageEvent": false, + "StorageManager": false, + "structuredClone": false, + "styleMedia": false, + "StylePropertyMap": false, + "StylePropertyMapReadOnly": false, + "StyleSheet": false, + "StyleSheetList": false, + "SubmitEvent": false, + "Subscriber": false, + "SubtleCrypto": false, + "Summarizer": false, + "SuppressedError": false, + "SVGAElement": false, + "SVGAngle": false, + "SVGAnimatedAngle": false, + "SVGAnimatedBoolean": false, + "SVGAnimatedEnumeration": false, + "SVGAnimatedInteger": false, + "SVGAnimatedLength": false, + "SVGAnimatedLengthList": false, + "SVGAnimatedNumber": false, + "SVGAnimatedNumberList": false, + "SVGAnimatedPreserveAspectRatio": false, + "SVGAnimatedRect": false, + "SVGAnimatedString": false, + "SVGAnimatedTransformList": false, + "SVGAnimateElement": false, + "SVGAnimateMotionElement": false, + "SVGAnimateTransformElement": false, + "SVGAnimationElement": false, + "SVGCircleElement": false, + "SVGClipPathElement": false, + "SVGComponentTransferFunctionElement": false, + "SVGDefsElement": false, + "SVGDescElement": false, + "SVGElement": false, + "SVGEllipseElement": false, + "SVGFEBlendElement": false, + "SVGFEColorMatrixElement": false, + "SVGFEComponentTransferElement": false, + "SVGFECompositeElement": false, + "SVGFEConvolveMatrixElement": false, + "SVGFEDiffuseLightingElement": false, + "SVGFEDisplacementMapElement": false, + "SVGFEDistantLightElement": false, + "SVGFEDropShadowElement": false, + "SVGFEFloodElement": false, + "SVGFEFuncAElement": false, + "SVGFEFuncBElement": false, + "SVGFEFuncGElement": false, + "SVGFEFuncRElement": false, + "SVGFEGaussianBlurElement": false, + "SVGFEImageElement": false, + "SVGFEMergeElement": false, + "SVGFEMergeNodeElement": false, + "SVGFEMorphologyElement": false, + "SVGFEOffsetElement": false, + "SVGFEPointLightElement": false, + "SVGFESpecularLightingElement": false, + "SVGFESpotLightElement": false, + "SVGFETileElement": false, + "SVGFETurbulenceElement": false, + "SVGFilterElement": false, + "SVGForeignObjectElement": false, + "SVGGElement": false, + "SVGGeometryElement": false, + "SVGGradientElement": false, + "SVGGraphicsElement": false, + "SVGImageElement": false, + "SVGLength": false, + "SVGLengthList": false, + "SVGLinearGradientElement": false, + "SVGLineElement": false, + "SVGMarkerElement": false, + "SVGMaskElement": false, + "SVGMatrix": false, + "SVGMetadataElement": false, + "SVGMPathElement": false, + "SVGNumber": false, + "SVGNumberList": false, + "SVGPathElement": false, + "SVGPatternElement": false, + "SVGPoint": false, + "SVGPointList": false, + "SVGPolygonElement": false, + "SVGPolylineElement": false, + "SVGPreserveAspectRatio": false, + "SVGRadialGradientElement": false, + "SVGRect": false, + "SVGRectElement": false, + "SVGScriptElement": false, + "SVGSetElement": false, + "SVGStopElement": false, + "SVGStringList": false, + "SVGStyleElement": false, + "SVGSVGElement": false, + "SVGSwitchElement": false, + "SVGSymbolElement": false, + "SVGTextContentElement": false, + "SVGTextElement": false, + "SVGTextPathElement": false, + "SVGTextPositioningElement": false, + "SVGTitleElement": false, + "SVGTransform": false, + "SVGTransformList": false, + "SVGTSpanElement": false, + "SVGUnitTypes": false, + "SVGUseElement": false, + "SVGViewElement": false, + "SyncManager": false, + "TaskAttributionTiming": false, + "TaskController": false, + "TaskPriorityChangeEvent": false, + "TaskSignal": false, + "TEMPORARY": false, + "Text": false, + "TextDecoder": false, + "TextDecoderStream": false, + "TextEncoder": false, + "TextEncoderStream": false, + "TextEvent": false, + "TextFormat": false, + "TextFormatUpdateEvent": false, + "TextMetrics": false, + "TextTrack": false, + "TextTrackCue": false, + "TextTrackCueList": false, + "TextTrackList": false, + "TextUpdateEvent": false, + "TimeEvent": false, + "TimeRanges": false, + "ToggleEvent": false, + "toolbar": false, + "top": false, + "Touch": false, + "TouchEvent": false, + "TouchList": false, + "TrackEvent": false, + "TransformStream": false, + "TransformStreamDefaultController": false, + "TransitionEvent": false, + "Translator": false, + "TreeWalker": false, + "TrustedHTML": false, + "TrustedScript": false, + "TrustedScriptURL": false, + "TrustedTypePolicy": false, + "TrustedTypePolicyFactory": false, + "trustedTypes": false, + "UIEvent": false, + "URL": false, + "URLPattern": false, + "URLSearchParams": false, + "USB": false, + "USBAlternateInterface": false, + "USBConfiguration": false, + "USBConnectionEvent": false, + "USBDevice": false, + "USBEndpoint": false, + "USBInterface": false, + "USBInTransferResult": false, + "USBIsochronousInTransferPacket": false, + "USBIsochronousInTransferResult": false, + "USBIsochronousOutTransferPacket": false, + "USBIsochronousOutTransferResult": false, + "USBOutTransferResult": false, + "UserActivation": false, + "ValidityState": false, + "VideoColorSpace": false, + "VideoDecoder": false, + "VideoEncoder": false, + "VideoFrame": false, + "VideoPlaybackQuality": false, + "viewport": false, + "Viewport": false, + "ViewTimeline": false, + "ViewTransition": false, + "ViewTransitionTypeSet": false, + "VirtualKeyboard": false, + "VirtualKeyboardGeometryChangeEvent": false, + "VisibilityStateEntry": false, + "visualViewport": false, + "VisualViewport": false, + "VTTCue": false, + "VTTRegion": false, + "WakeLock": false, + "WakeLockSentinel": false, + "WaveShaperNode": false, + "WebAssembly": false, + "WebGL2RenderingContext": false, + "WebGLActiveInfo": false, + "WebGLBuffer": false, + "WebGLContextEvent": false, + "WebGLFramebuffer": false, + "WebGLObject": false, + "WebGLProgram": false, + "WebGLQuery": false, + "WebGLRenderbuffer": false, + "WebGLRenderingContext": false, + "WebGLSampler": false, + "WebGLShader": false, + "WebGLShaderPrecisionFormat": false, + "WebGLSync": false, + "WebGLTexture": false, + "WebGLTransformFeedback": false, + "WebGLUniformLocation": false, + "WebGLVertexArrayObject": false, + "WebSocket": false, + "WebSocketError": false, + "WebSocketStream": false, + "WebTransport": false, + "WebTransportBidirectionalStream": false, + "WebTransportDatagramDuplexStream": false, + "WebTransportError": false, + "WebTransportReceiveStream": false, + "WebTransportSendStream": false, + "WGSLLanguageFeatures": false, + "WheelEvent": false, + "when": false, + "window": false, + "Window": false, + "WindowControlsOverlay": false, + "WindowControlsOverlayGeometryChangeEvent": false, + "Worker": false, + "Worklet": false, + "WorkletGlobalScope": false, + "WritableStream": false, + "WritableStreamDefaultController": false, + "WritableStreamDefaultWriter": false, + "XMLDocument": false, + "XMLHttpRequest": false, + "XMLHttpRequestEventTarget": false, + "XMLHttpRequestUpload": false, + "XMLSerializer": false, + "XPathEvaluator": false, + "XPathExpression": false, + "XPathResult": false, + "XRAnchor": false, + "XRAnchorSet": false, + "XRBoundedReferenceSpace": false, + "XRCamera": false, + "XRCPUDepthInformation": false, + "XRDepthInformation": false, + "XRDOMOverlayState": false, + "XRFrame": false, + "XRHand": false, + "XRHitTestResult": false, + "XRHitTestSource": false, + "XRInputSource": false, + "XRInputSourceArray": false, + "XRInputSourceEvent": false, + "XRInputSourcesChangeEvent": false, + "XRJointPose": false, + "XRJointSpace": false, + "XRLayer": false, + "XRLightEstimate": false, + "XRLightProbe": false, + "XRPose": false, + "XRRay": false, + "XRReferenceSpace": false, + "XRReferenceSpaceEvent": false, + "XRRenderState": false, + "XRRigidTransform": false, + "XRSession": false, + "XRSessionEvent": false, + "XRSpace": false, + "XRSystem": false, + "XRTransientInputHitTestResult": false, + "XRTransientInputHitTestSource": false, + "XRView": false, + "XRViewerPose": false, + "XRViewport": false, + "XRWebGLBinding": false, + "XRWebGLDepthInformation": false, + "XRWebGLLayer": false, + "XSLTProcessor": false + }, + "builtin": { + "AggregateError": false, + "Array": false, + "ArrayBuffer": false, + "Atomics": false, + "BigInt": false, + "BigInt64Array": false, + "BigUint64Array": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "FinalizationRegistry": false, + "Float16Array": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "globalThis": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "Iterator": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "SharedArrayBuffer": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakRef": false, + "WeakSet": false + }, + "chai": { + "assert": true, + "expect": true, + "should": true + }, + "commonjs": { + "exports": true, + "global": false, + "module": false, + "require": false + }, + "couch": { + "emit": false, + "exports": false, + "getRow": false, + "log": false, + "module": false, + "provides": false, + "require": false, + "respond": false, + "send": false, + "start": false, + "sum": false + }, + "devtools": { + "$": false, + "$_": false, + "$$": false, + "$0": false, + "$1": false, + "$2": false, + "$3": false, + "$4": false, + "$x": false, + "chrome": false, + "clear": false, + "copy": false, + "debug": false, + "dir": false, + "dirxml": false, + "getEventListeners": false, + "inspect": false, + "keys": false, + "monitor": false, + "monitorEvents": false, + "profile": false, + "profileEnd": false, + "queryObjects": false, + "table": false, + "undebug": false, + "unmonitor": false, + "unmonitorEvents": false, + "values": false + }, + "embertest": { + "andThen": false, + "click": false, + "currentPath": false, + "currentRouteName": false, + "currentURL": false, + "fillIn": false, + "find": false, + "findAll": false, + "findWithAssert": false, + "keyEvent": false, + "pauseTest": false, + "resumeTest": false, + "triggerEvent": false, + "visit": false, + "wait": false + }, + "es2015": { + "Array": false, + "ArrayBuffer": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakSet": false + }, + "es2016": { + "Array": false, + "ArrayBuffer": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakSet": false + }, + "es2017": { + "Array": false, + "ArrayBuffer": false, + "Atomics": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "SharedArrayBuffer": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakSet": false + }, + "es2018": { + "Array": false, + "ArrayBuffer": false, + "Atomics": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "SharedArrayBuffer": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakSet": false + }, + "es2019": { + "Array": false, + "ArrayBuffer": false, + "Atomics": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "SharedArrayBuffer": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakSet": false + }, + "es2020": { + "Array": false, + "ArrayBuffer": false, + "Atomics": false, + "BigInt": false, + "BigInt64Array": false, + "BigUint64Array": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "globalThis": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "SharedArrayBuffer": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakSet": false + }, + "es2021": { + "AggregateError": false, + "Array": false, + "ArrayBuffer": false, + "Atomics": false, + "BigInt": false, + "BigInt64Array": false, + "BigUint64Array": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "FinalizationRegistry": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "globalThis": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "SharedArrayBuffer": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakRef": false, + "WeakSet": false + }, + "es2022": { + "AggregateError": false, + "Array": false, + "ArrayBuffer": false, + "Atomics": false, + "BigInt": false, + "BigInt64Array": false, + "BigUint64Array": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "FinalizationRegistry": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "globalThis": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "SharedArrayBuffer": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakRef": false, + "WeakSet": false + }, + "es2023": { + "AggregateError": false, + "Array": false, + "ArrayBuffer": false, + "Atomics": false, + "BigInt": false, + "BigInt64Array": false, + "BigUint64Array": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "FinalizationRegistry": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "globalThis": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "SharedArrayBuffer": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakRef": false, + "WeakSet": false + }, + "es2024": { + "AggregateError": false, + "Array": false, + "ArrayBuffer": false, + "Atomics": false, + "BigInt": false, + "BigInt64Array": false, + "BigUint64Array": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "FinalizationRegistry": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "globalThis": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "SharedArrayBuffer": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakRef": false, + "WeakSet": false + }, + "es2025": { + "AggregateError": false, + "Array": false, + "ArrayBuffer": false, + "Atomics": false, + "BigInt": false, + "BigInt64Array": false, + "BigUint64Array": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "FinalizationRegistry": false, + "Float16Array": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "globalThis": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "Iterator": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "SharedArrayBuffer": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakRef": false, + "WeakSet": false + }, + "es2026": { + "AggregateError": false, + "Array": false, + "ArrayBuffer": false, + "Atomics": false, + "BigInt": false, + "BigInt64Array": false, + "BigUint64Array": false, + "Boolean": false, + "DataView": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "FinalizationRegistry": false, + "Float16Array": false, + "Float32Array": false, + "Float64Array": false, + "Function": false, + "globalThis": false, + "Infinity": false, + "Int16Array": false, + "Int32Array": false, + "Int8Array": false, + "Intl": false, + "isFinite": false, + "isNaN": false, + "Iterator": false, + "JSON": false, + "Map": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "Promise": false, + "Proxy": false, + "RangeError": false, + "ReferenceError": false, + "Reflect": false, + "RegExp": false, + "Set": false, + "SharedArrayBuffer": false, + "String": false, + "Symbol": false, + "SyntaxError": false, + "TypeError": false, + "Uint16Array": false, + "Uint32Array": false, + "Uint8Array": false, + "Uint8ClampedArray": false, + "undefined": false, + "unescape": false, + "URIError": false, + "WeakMap": false, + "WeakRef": false, + "WeakSet": false + }, + "es3": { + "Array": false, + "Boolean": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "Function": false, + "Infinity": false, + "isFinite": false, + "isNaN": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "RangeError": false, + "ReferenceError": false, + "RegExp": false, + "String": false, + "SyntaxError": false, + "TypeError": false, + "undefined": false, + "unescape": false, + "URIError": false + }, + "es5": { + "Array": false, + "Boolean": false, + "Date": false, + "decodeURI": false, + "decodeURIComponent": false, + "encodeURI": false, + "encodeURIComponent": false, + "Error": false, + "escape": false, + "eval": false, + "EvalError": false, + "Function": false, + "Infinity": false, + "isFinite": false, + "isNaN": false, + "JSON": false, + "Math": false, + "NaN": false, + "Number": false, + "Object": false, + "parseFloat": false, + "parseInt": false, + "RangeError": false, + "ReferenceError": false, + "RegExp": false, + "String": false, + "SyntaxError": false, + "TypeError": false, + "undefined": false, + "unescape": false, + "URIError": false + }, + "greasemonkey": { + "cloneInto": false, + "createObjectIn": false, + "exportFunction": false, + "GM": false, + "GM_addElement": false, + "GM_addStyle": false, + "GM_addValueChangeListener": false, + "GM_deleteValue": false, + "GM_deleteValues": false, + "GM_download": false, + "GM_getResourceText": false, + "GM_getResourceURL": false, + "GM_getTab": false, + "GM_getTabs": false, + "GM_getValue": false, + "GM_getValues": false, + "GM_info": false, + "GM_listValues": false, + "GM_log": false, + "GM_notification": false, + "GM_openInTab": false, + "GM_registerMenuCommand": false, + "GM_removeValueChangeListener": false, + "GM_saveTab": false, + "GM_setClipboard": false, + "GM_setValue": false, + "GM_setValues": false, + "GM_unregisterMenuCommand": false, + "GM_xmlhttpRequest": false, + "unsafeWindow": false + }, + "jasmine": { + "afterAll": false, + "afterEach": false, + "beforeAll": false, + "beforeEach": false, + "describe": false, + "expect": false, + "expectAsync": false, + "fail": false, + "fdescribe": false, + "fit": false, + "it": false, + "jasmine": false, + "pending": false, + "runs": false, + "spyOn": false, + "spyOnAllFunctions": false, + "spyOnProperty": false, + "waits": false, + "waitsFor": false, + "xdescribe": false, + "xit": false + }, + "jest": { + "afterAll": false, + "afterEach": false, + "beforeAll": false, + "beforeEach": false, + "describe": false, + "expect": false, + "fit": false, + "it": false, + "jest": false, + "test": false, + "xdescribe": false, + "xit": false, + "xtest": false + }, + "jquery": { + "$": false, + "jQuery": false + }, + "meteor": { + "$": false, + "Accounts": false, + "AccountsClient": false, + "AccountsCommon": false, + "AccountsServer": false, + "App": false, + "Assets": false, + "Blaze": false, + "check": false, + "Cordova": false, + "DDP": false, + "DDPRateLimiter": false, + "DDPServer": false, + "Deps": false, + "EJSON": false, + "Email": false, + "HTTP": false, + "Log": false, + "Match": false, + "Meteor": false, + "Mongo": false, + "MongoInternals": false, + "Npm": false, + "Package": false, + "Plugin": false, + "process": false, + "Random": false, + "ReactiveDict": false, + "ReactiveVar": false, + "Router": false, + "ServiceConfiguration": false, + "Session": false, + "share": false, + "Spacebars": false, + "Template": false, + "Tinytest": false, + "Tracker": false, + "UI": false, + "Utils": false, + "WebApp": false, + "WebAppInternals": false + }, + "mocha": { + "after": false, + "afterEach": false, + "before": false, + "beforeEach": false, + "context": false, + "describe": false, + "it": false, + "mocha": false, + "run": false, + "setup": false, + "specify": false, + "suite": false, + "suiteSetup": false, + "suiteTeardown": false, + "teardown": false, + "test": false, + "xcontext": false, + "xdescribe": false, + "xit": false, + "xspecify": false + }, + "mongo": { + "_isWindows": false, + "_rand": false, + "BulkWriteResult": false, + "cat": false, + "cd": false, + "connect": false, + "db": false, + "getHostName": false, + "getMemInfo": false, + "hostname": false, + "ISODate": false, + "listFiles": false, + "load": false, + "ls": false, + "md5sumFile": false, + "mkdir": false, + "Mongo": false, + "NumberInt": false, + "NumberLong": false, + "ObjectId": false, + "PlanCache": false, + "print": false, + "printjson": false, + "pwd": false, + "quit": false, + "removeFile": false, + "rs": false, + "sh": false, + "UUID": false, + "version": false, + "WriteResult": false + }, + "nashorn": { + "__DIR__": false, + "__FILE__": false, + "__LINE__": false, + "com": false, + "edu": false, + "exit": false, + "java": false, + "Java": false, + "javafx": false, + "JavaImporter": false, + "javax": false, + "JSAdapter": false, + "load": false, + "loadWithNewGlobal": false, + "org": false, + "Packages": false, + "print": false, + "quit": false + }, + "node": { + "__dirname": false, + "__filename": false, + "AbortController": false, + "AbortSignal": false, + "AsyncDisposableStack": false, + "atob": false, + "Blob": false, + "BroadcastChannel": false, + "btoa": false, + "Buffer": false, + "ByteLengthQueuingStrategy": false, + "clearImmediate": false, + "clearInterval": false, + "clearTimeout": false, + "CloseEvent": false, + "CompressionStream": false, + "console": false, + "CountQueuingStrategy": false, + "crypto": false, + "Crypto": false, + "CryptoKey": false, + "CustomEvent": false, + "DecompressionStream": false, + "DisposableStack": false, + "DOMException": false, + "ErrorEvent": false, + "Event": false, + "EventTarget": false, + "exports": true, + "fetch": false, + "File": false, + "FormData": false, + "global": false, + "Headers": false, + "localStorage": false, + "MessageChannel": false, + "MessageEvent": false, + "MessagePort": false, + "module": false, + "navigator": false, + "Navigator": false, + "performance": false, + "Performance": false, + "PerformanceEntry": false, + "PerformanceMark": false, + "PerformanceMeasure": false, + "PerformanceObserver": false, + "PerformanceObserverEntryList": false, + "PerformanceResourceTiming": false, + "process": false, + "queueMicrotask": false, + "ReadableByteStreamController": false, + "ReadableStream": false, + "ReadableStreamBYOBReader": false, + "ReadableStreamBYOBRequest": false, + "ReadableStreamDefaultController": false, + "ReadableStreamDefaultReader": false, + "Request": false, + "require": false, + "Response": false, + "sessionStorage": false, + "setImmediate": false, + "setInterval": false, + "setTimeout": false, + "Storage": false, + "structuredClone": false, + "SubtleCrypto": false, + "SuppressedError": false, + "TextDecoder": false, + "TextDecoderStream": false, + "TextEncoder": false, + "TextEncoderStream": false, + "TransformStream": false, + "TransformStreamDefaultController": false, + "URL": false, + "URLPattern": false, + "URLSearchParams": false, + "WebAssembly": false, + "WebSocket": false, + "WritableStream": false, + "WritableStreamDefaultController": false, + "WritableStreamDefaultWriter": false + }, + "nodeBuiltin": { + "AbortController": false, + "AbortSignal": false, + "AsyncDisposableStack": false, + "atob": false, + "Blob": false, + "BroadcastChannel": false, + "btoa": false, + "Buffer": false, + "ByteLengthQueuingStrategy": false, + "clearImmediate": false, + "clearInterval": false, + "clearTimeout": false, + "CloseEvent": false, + "CompressionStream": false, + "console": false, + "CountQueuingStrategy": false, + "crypto": false, + "Crypto": false, + "CryptoKey": false, + "CustomEvent": false, + "DecompressionStream": false, + "DisposableStack": false, + "DOMException": false, + "ErrorEvent": false, + "Event": false, + "EventTarget": false, + "fetch": false, + "File": false, + "FormData": false, + "global": false, + "Headers": false, + "localStorage": false, + "MessageChannel": false, + "MessageEvent": false, + "MessagePort": false, + "navigator": false, + "Navigator": false, + "performance": false, + "Performance": false, + "PerformanceEntry": false, + "PerformanceMark": false, + "PerformanceMeasure": false, + "PerformanceObserver": false, + "PerformanceObserverEntryList": false, + "PerformanceResourceTiming": false, + "process": false, + "queueMicrotask": false, + "ReadableByteStreamController": false, + "ReadableStream": false, + "ReadableStreamBYOBReader": false, + "ReadableStreamBYOBRequest": false, + "ReadableStreamDefaultController": false, + "ReadableStreamDefaultReader": false, + "Request": false, + "Response": false, + "sessionStorage": false, + "setImmediate": false, + "setInterval": false, + "setTimeout": false, + "Storage": false, + "structuredClone": false, + "SubtleCrypto": false, + "SuppressedError": false, + "TextDecoder": false, + "TextDecoderStream": false, + "TextEncoder": false, + "TextEncoderStream": false, + "TransformStream": false, + "TransformStreamDefaultController": false, + "URL": false, + "URLPattern": false, + "URLSearchParams": false, + "WebAssembly": false, + "WebSocket": false, + "WritableStream": false, + "WritableStreamDefaultController": false, + "WritableStreamDefaultWriter": false + }, + "phantomjs": { + "console": true, + "exports": true, + "phantom": true, + "require": true, + "WebPage": true + }, + "prototypejs": { + "$": false, + "$$": false, + "$A": false, + "$break": false, + "$continue": false, + "$F": false, + "$H": false, + "$R": false, + "$w": false, + "Abstract": false, + "Ajax": false, + "Autocompleter": false, + "Builder": false, + "Class": false, + "Control": false, + "Draggable": false, + "Draggables": false, + "Droppables": false, + "Effect": false, + "Element": false, + "Enumerable": false, + "Event": false, + "Field": false, + "Form": false, + "Hash": false, + "Insertion": false, + "ObjectRange": false, + "PeriodicalExecuter": false, + "Position": false, + "Prototype": false, + "Scriptaculous": false, + "Selector": false, + "Sortable": false, + "SortableObserver": false, + "Sound": false, + "Template": false, + "Toggle": false, + "Try": false + }, + "protractor": { + "$": false, + "$$": false, + "browser": false, + "by": false, + "By": false, + "DartObject": false, + "element": false, + "protractor": false + }, + "qunit": { + "asyncTest": false, + "deepEqual": false, + "equal": false, + "expect": false, + "module": false, + "notDeepEqual": false, + "notEqual": false, + "notOk": false, + "notPropEqual": false, + "notStrictEqual": false, + "ok": false, + "propEqual": false, + "QUnit": false, + "raises": false, + "start": false, + "stop": false, + "strictEqual": false, + "test": false, + "throws": false + }, + "rhino": { + "defineClass": false, + "deserialize": false, + "gc": false, + "help": false, + "importClass": false, + "importPackage": false, + "java": false, + "load": false, + "loadClass": false, + "Packages": false, + "print": false, + "quit": false, + "readFile": false, + "readUrl": false, + "runCommand": false, + "seal": false, + "serialize": false, + "spawn": false, + "sync": false, + "toint32": false, + "version": false + }, + "serviceworker": { + "AbortController": false, + "AbortPaymentEvent": false, + "AbortSignal": false, + "addEventListener": false, + "ai": false, + "AI": false, + "AICreateMonitor": false, + "AsyncDisposableStack": false, + "atob": false, + "BackgroundFetchEvent": false, + "BackgroundFetchManager": false, + "BackgroundFetchRecord": false, + "BackgroundFetchRegistration": false, + "BackgroundFetchUpdateUIEvent": false, + "BarcodeDetector": false, + "Blob": false, + "BroadcastChannel": false, + "btoa": false, + "ByteLengthQueuingStrategy": false, + "Cache": false, + "caches": false, + "CacheStorage": false, + "CanMakePaymentEvent": false, + "CanvasGradient": false, + "CanvasPattern": false, + "clearInterval": false, + "clearTimeout": false, + "Client": false, + "clients": false, + "Clients": false, + "CloseEvent": false, + "CompressionStream": false, + "console": false, + "cookieStore": false, + "CookieStore": false, + "CookieStoreManager": false, + "CountQueuingStrategy": false, + "createImageBitmap": false, + "CreateMonitor": false, + "CropTarget": false, + "crossOriginIsolated": false, + "crypto": false, + "Crypto": false, + "CryptoKey": false, + "CSSSkewX": false, + "CSSSkewY": false, + "CustomEvent": false, + "DecompressionStream": false, + "dispatchEvent": false, + "DisposableStack": false, + "DOMException": false, + "DOMMatrix": false, + "DOMMatrixReadOnly": false, + "DOMPoint": false, + "DOMPointReadOnly": false, + "DOMQuad": false, + "DOMRect": false, + "DOMRectReadOnly": false, + "DOMStringList": false, + "ErrorEvent": false, + "Event": false, + "EventSource": false, + "EventTarget": false, + "ExtendableCookieChangeEvent": false, + "ExtendableEvent": false, + "ExtendableMessageEvent": false, + "fetch": false, + "FetchEvent": false, + "File": false, + "FileList": false, + "FileReader": false, + "FileSystemDirectoryHandle": false, + "FileSystemFileHandle": false, + "FileSystemHandle": false, + "FileSystemWritableFileStream": false, + "FontFace": false, + "fonts": false, + "FormData": false, + "GPU": false, + "GPUAdapter": false, + "GPUAdapterInfo": false, + "GPUBindGroup": false, + "GPUBindGroupLayout": false, + "GPUBuffer": false, + "GPUBufferUsage": false, + "GPUCanvasContext": false, + "GPUColorWrite": false, + "GPUCommandBuffer": false, + "GPUCommandEncoder": false, + "GPUCompilationInfo": false, + "GPUCompilationMessage": false, + "GPUComputePassEncoder": false, + "GPUComputePipeline": false, + "GPUDevice": false, + "GPUDeviceLostInfo": false, + "GPUError": false, + "GPUExternalTexture": false, + "GPUInternalError": false, + "GPUMapMode": false, + "GPUOutOfMemoryError": false, + "GPUPipelineError": false, + "GPUPipelineLayout": false, + "GPUQuerySet": false, + "GPUQueue": false, + "GPURenderBundle": false, + "GPURenderBundleEncoder": false, + "GPURenderPassEncoder": false, + "GPURenderPipeline": false, + "GPUSampler": false, + "GPUShaderModule": false, + "GPUShaderStage": false, + "GPUSupportedFeatures": false, + "GPUSupportedLimits": false, + "GPUTexture": false, + "GPUTextureUsage": false, + "GPUTextureView": false, + "GPUUncapturedErrorEvent": false, + "GPUValidationError": false, + "Headers": false, + "IDBCursor": false, + "IDBCursorWithValue": false, + "IDBDatabase": false, + "IDBFactory": false, + "IDBIndex": false, + "IDBKeyRange": false, + "IDBObjectStore": false, + "IDBOpenDBRequest": false, + "IDBRecord": false, + "IDBRequest": false, + "IDBTransaction": false, + "IDBVersionChangeEvent": false, + "ImageBitmap": false, + "ImageBitmapRenderingContext": false, + "ImageData": false, + "importScripts": false, + "indexedDB": false, + "InstallEvent": false, + "isSecureContext": false, + "LanguageDetector": false, + "location": false, + "Lock": false, + "LockManager": false, + "MediaCapabilities": false, + "MessageChannel": false, + "MessageEvent": false, + "MessagePort": false, + "NavigationPreloadManager": false, + "navigator": false, + "NavigatorUAData": false, + "NetworkInformation": false, + "Notification": false, + "NotificationEvent": false, + "Observable": false, + "OffscreenCanvas": false, + "OffscreenCanvasRenderingContext2D": false, + "onabortpayment": true, + "onactivate": true, + "onbackgroundfetchabort": true, + "onbackgroundfetchclick": true, + "onbackgroundfetchfail": true, + "onbackgroundfetchsuccess": true, + "oncanmakepayment": true, + "oncookiechange": true, + "onerror": true, + "onfetch": true, + "oninstall": true, + "onlanguagechange": true, + "onmessage": true, + "onmessageerror": true, + "onnotificationclick": true, + "onnotificationclose": true, + "onpaymentrequest": true, + "onperiodicsync": true, + "onpush": true, + "onpushsubscriptionchange": true, + "onrejectionhandled": true, + "onsync": true, + "onunhandledrejection": true, + "origin": false, + "Path2D": false, + "PaymentRequestEvent": false, + "performance": false, + "Performance": false, + "PerformanceEntry": false, + "PerformanceMark": false, + "PerformanceMeasure": false, + "PerformanceObserver": false, + "PerformanceObserverEntryList": false, + "PerformanceResourceTiming": false, + "PerformanceServerTiming": false, + "PeriodicSyncEvent": false, + "PeriodicSyncManager": false, + "Permissions": false, + "PermissionStatus": false, + "PromiseRejectionEvent": false, + "PushEvent": false, + "PushManager": false, + "PushMessageData": false, + "PushSubscription": false, + "PushSubscriptionChangeEvent": false, + "PushSubscriptionOptions": false, + "queueMicrotask": false, + "QuotaExceededError": false, + "ReadableByteStreamController": false, + "ReadableStream": false, + "ReadableStreamBYOBReader": false, + "ReadableStreamBYOBRequest": false, + "ReadableStreamDefaultController": false, + "ReadableStreamDefaultReader": false, + "registration": false, + "removeEventListener": false, + "ReportBody": false, + "reportError": false, + "ReportingObserver": false, + "Request": false, + "Response": false, + "RestrictionTarget": false, + "scheduler": false, + "Scheduler": false, + "SecurityPolicyViolationEvent": false, + "self": false, + "serviceWorker": false, + "ServiceWorker": false, + "ServiceWorkerGlobalScope": false, + "ServiceWorkerRegistration": false, + "setInterval": false, + "setTimeout": false, + "skipWaiting": false, + "StorageBucket": false, + "StorageBucketManager": false, + "StorageManager": false, + "structuredClone": false, + "Subscriber": false, + "SubtleCrypto": false, + "SuppressedError": false, + "SyncEvent": false, + "SyncManager": false, + "TaskController": false, + "TaskPriorityChangeEvent": false, + "TaskSignal": false, + "TextDecoder": false, + "TextDecoderStream": false, + "TextEncoder": false, + "TextEncoderStream": false, + "TextMetrics": false, + "TransformStream": false, + "TransformStreamDefaultController": false, + "TrustedHTML": false, + "TrustedScript": false, + "TrustedScriptURL": false, + "TrustedTypePolicy": false, + "TrustedTypePolicyFactory": false, + "trustedTypes": false, + "URL": false, + "URLPattern": false, + "URLSearchParams": false, + "UserActivation": false, + "WebAssembly": false, + "WebGL2RenderingContext": false, + "WebGLActiveInfo": false, + "WebGLBuffer": false, + "WebGLContextEvent": false, + "WebGLFramebuffer": false, + "WebGLObject": false, + "WebGLProgram": false, + "WebGLQuery": false, + "WebGLRenderbuffer": false, + "WebGLRenderingContext": false, + "WebGLSampler": false, + "WebGLShader": false, + "WebGLShaderPrecisionFormat": false, + "WebGLSync": false, + "WebGLTexture": false, + "WebGLTransformFeedback": false, + "WebGLUniformLocation": false, + "WebGLVertexArrayObject": false, + "WebSocket": false, + "WebSocketError": false, + "WebSocketStream": false, + "WebTransport": false, + "WebTransportBidirectionalStream": false, + "WebTransportDatagramDuplexStream": false, + "WebTransportError": false, + "WGSLLanguageFeatures": false, + "when": false, + "WindowClient": false, + "WorkerGlobalScope": false, + "WorkerLocation": false, + "WorkerNavigator": false, + "WritableStream": false, + "WritableStreamDefaultController": false, + "WritableStreamDefaultWriter": false + }, + "shared-node-browser": { + "AbortController": false, + "AbortSignal": false, + "AsyncDisposableStack": false, + "atob": false, + "Blob": false, + "BroadcastChannel": false, + "btoa": false, + "ByteLengthQueuingStrategy": false, + "clearInterval": false, + "clearTimeout": false, + "CloseEvent": false, + "CompressionStream": false, + "console": false, + "CountQueuingStrategy": false, + "crypto": false, + "Crypto": false, + "CryptoKey": false, + "CustomEvent": false, + "DecompressionStream": false, + "DisposableStack": false, + "DOMException": false, + "ErrorEvent": false, + "Event": false, + "EventTarget": false, + "fetch": false, + "File": false, + "FormData": false, + "Headers": false, + "localStorage": false, + "MessageChannel": false, + "MessageEvent": false, + "MessagePort": false, + "navigator": false, + "Navigator": false, + "performance": false, + "Performance": false, + "PerformanceEntry": false, + "PerformanceMark": false, + "PerformanceMeasure": false, + "PerformanceObserver": false, + "PerformanceObserverEntryList": false, + "PerformanceResourceTiming": false, + "queueMicrotask": false, + "ReadableByteStreamController": false, + "ReadableStream": false, + "ReadableStreamBYOBReader": false, + "ReadableStreamBYOBRequest": false, + "ReadableStreamDefaultController": false, + "ReadableStreamDefaultReader": false, + "Request": false, + "Response": false, + "sessionStorage": false, + "setInterval": false, + "setTimeout": false, + "Storage": false, + "structuredClone": false, + "SubtleCrypto": false, + "SuppressedError": false, + "TextDecoder": false, + "TextDecoderStream": false, + "TextEncoder": false, + "TextEncoderStream": false, + "TransformStream": false, + "TransformStreamDefaultController": false, + "URL": false, + "URLPattern": false, + "URLSearchParams": false, + "WebAssembly": false, + "WebSocket": false, + "WritableStream": false, + "WritableStreamDefaultController": false, + "WritableStreamDefaultWriter": false + }, + "shelljs": { + "cat": false, + "cd": false, + "chmod": false, + "cmd": false, + "config": false, + "cp": false, + "dirs": false, + "echo": false, + "env": false, + "error": false, + "errorCode": false, + "exec": false, + "exit": false, + "find": false, + "grep": false, + "head": false, + "ln": false, + "ls": false, + "mkdir": false, + "mv": false, + "popd": false, + "pushd": false, + "pwd": false, + "rm": false, + "sed": false, + "set": false, + "ShellString": false, + "sort": false, + "tail": false, + "tempdir": false, + "test": false, + "touch": false, + "uniq": false, + "which": false + }, + "svelte": { + "$bindable": false, + "$derived": false, + "$effect": false, + "$host": false, + "$inspect": false, + "$props": false, + "$state": false + }, + "vitest": { + "afterAll": false, + "afterEach": false, + "assert": false, + "assertType": false, + "beforeAll": false, + "beforeEach": false, + "chai": false, + "describe": false, + "expect": false, + "expectTypeOf": false, + "it": false, + "onTestFailed": false, + "onTestFinished": false, + "suite": false, + "test": false, + "vi": false, + "vitest": false + }, + "vue": { + "defineEmits": false, + "defineExpose": false, + "defineModel": false, + "defineOptions": false, + "defineProps": false, + "defineSlots": false, + "withDefaults": false + }, + "webextensions": { + "browser": false, + "chrome": false, + "opr": false + }, + "worker": { + "AbortController": false, + "AbortSignal": false, + "addEventListener": false, + "ai": false, + "AI": false, + "AICreateMonitor": false, + "AsyncDisposableStack": false, + "atob": false, + "AudioData": false, + "AudioDecoder": false, + "AudioEncoder": false, + "BackgroundFetchManager": false, + "BackgroundFetchRecord": false, + "BackgroundFetchRegistration": false, + "BarcodeDetector": false, + "Blob": false, + "BroadcastChannel": false, + "btoa": false, + "ByteLengthQueuingStrategy": false, + "Cache": false, + "caches": false, + "CacheStorage": false, + "cancelAnimationFrame": false, + "CanvasGradient": false, + "CanvasPattern": false, + "clearInterval": false, + "clearTimeout": false, + "close": false, + "CloseEvent": false, + "CompressionStream": false, + "console": false, + "CountQueuingStrategy": false, + "createImageBitmap": false, + "CreateMonitor": false, + "CropTarget": false, + "crossOriginIsolated": false, + "crypto": false, + "Crypto": false, + "CryptoKey": false, + "CSSSkewX": false, + "CSSSkewY": false, + "CustomEvent": false, + "DecompressionStream": false, + "DedicatedWorkerGlobalScope": false, + "dispatchEvent": false, + "DisposableStack": false, + "DOMException": false, + "DOMMatrix": false, + "DOMMatrixReadOnly": false, + "DOMPoint": false, + "DOMPointReadOnly": false, + "DOMQuad": false, + "DOMRect": false, + "DOMRectReadOnly": false, + "DOMStringList": false, + "EncodedAudioChunk": false, + "EncodedVideoChunk": false, + "ErrorEvent": false, + "Event": false, + "EventSource": false, + "EventTarget": false, + "fetch": false, + "File": false, + "FileList": false, + "FileReader": false, + "FileReaderSync": false, + "FileSystemDirectoryHandle": false, + "FileSystemFileHandle": false, + "FileSystemHandle": false, + "FileSystemObserver": false, + "FileSystemSyncAccessHandle": false, + "FileSystemWritableFileStream": false, + "FontFace": false, + "fonts": false, + "FormData": false, + "GPU": false, + "GPUAdapter": false, + "GPUAdapterInfo": false, + "GPUBindGroup": false, + "GPUBindGroupLayout": false, + "GPUBuffer": false, + "GPUBufferUsage": false, + "GPUCanvasContext": false, + "GPUColorWrite": false, + "GPUCommandBuffer": false, + "GPUCommandEncoder": false, + "GPUCompilationInfo": false, + "GPUCompilationMessage": false, + "GPUComputePassEncoder": false, + "GPUComputePipeline": false, + "GPUDevice": false, + "GPUDeviceLostInfo": false, + "GPUError": false, + "GPUExternalTexture": false, + "GPUInternalError": false, + "GPUMapMode": false, + "GPUOutOfMemoryError": false, + "GPUPipelineError": false, + "GPUPipelineLayout": false, + "GPUQuerySet": false, + "GPUQueue": false, + "GPURenderBundle": false, + "GPURenderBundleEncoder": false, + "GPURenderPassEncoder": false, + "GPURenderPipeline": false, + "GPUSampler": false, + "GPUShaderModule": false, + "GPUShaderStage": false, + "GPUSupportedFeatures": false, + "GPUSupportedLimits": false, + "GPUTexture": false, + "GPUTextureUsage": false, + "GPUTextureView": false, + "GPUUncapturedErrorEvent": false, + "GPUValidationError": false, + "Headers": false, + "HID": false, + "HIDConnectionEvent": false, + "HIDDevice": false, + "HIDInputReportEvent": false, + "IDBCursor": false, + "IDBCursorWithValue": false, + "IDBDatabase": false, + "IDBFactory": false, + "IDBIndex": false, + "IDBKeyRange": false, + "IDBObjectStore": false, + "IDBOpenDBRequest": false, + "IDBRecord": false, + "IDBRequest": false, + "IDBTransaction": false, + "IDBVersionChangeEvent": false, + "IdleDetector": false, + "ImageBitmap": false, + "ImageBitmapRenderingContext": false, + "ImageData": false, + "ImageDecoder": false, + "ImageTrack": false, + "ImageTrackList": false, + "importScripts": false, + "indexedDB": false, + "isSecureContext": false, + "LanguageDetector": false, + "location": false, + "Lock": false, + "LockManager": false, + "MediaCapabilities": false, + "MediaSource": false, + "MediaSourceHandle": false, + "MessageChannel": false, + "MessageEvent": false, + "MessagePort": false, + "name": false, + "NavigationPreloadManager": false, + "navigator": false, + "NavigatorUAData": false, + "NetworkInformation": false, + "Notification": false, + "Observable": false, + "OffscreenCanvas": false, + "OffscreenCanvasRenderingContext2D": false, + "onerror": true, + "onlanguagechange": true, + "onmessage": true, + "onmessageerror": true, + "onrejectionhandled": true, + "onrtctransform": true, + "onunhandledrejection": true, + "origin": false, + "Path2D": false, + "performance": false, + "Performance": false, + "PerformanceEntry": false, + "PerformanceMark": false, + "PerformanceMeasure": false, + "PerformanceObserver": false, + "PerformanceObserverEntryList": false, + "PerformanceResourceTiming": false, + "PerformanceServerTiming": false, + "PeriodicSyncManager": false, + "Permissions": false, + "PermissionStatus": false, + "PERSISTENT": false, + "postMessage": false, + "PressureObserver": false, + "PressureRecord": false, + "ProgressEvent": false, + "PromiseRejectionEvent": false, + "PushManager": false, + "PushSubscription": false, + "PushSubscriptionOptions": false, + "queueMicrotask": false, + "QuotaExceededError": false, + "ReadableByteStreamController": false, + "ReadableStream": false, + "ReadableStreamBYOBReader": false, + "ReadableStreamBYOBRequest": false, + "ReadableStreamDefaultController": false, + "ReadableStreamDefaultReader": false, + "removeEventListener": false, + "ReportBody": false, + "reportError": false, + "ReportingObserver": false, + "Request": false, + "requestAnimationFrame": false, + "Response": false, + "RestrictionTarget": false, + "RTCDataChannel": false, + "RTCEncodedAudioFrame": false, + "RTCEncodedVideoFrame": false, + "RTCRtpScriptTransformer": false, + "RTCTransformEvent": false, + "scheduler": false, + "Scheduler": false, + "SecurityPolicyViolationEvent": false, + "self": false, + "Serial": false, + "SerialPort": false, + "ServiceWorkerRegistration": false, + "setInterval": false, + "setTimeout": false, + "SourceBuffer": false, + "SourceBufferList": false, + "StorageBucket": false, + "StorageBucketManager": false, + "StorageManager": false, + "structuredClone": false, + "Subscriber": false, + "SubtleCrypto": false, + "SuppressedError": false, + "SyncManager": false, + "TaskController": false, + "TaskPriorityChangeEvent": false, + "TaskSignal": false, + "TEMPORARY": false, + "TextDecoder": false, + "TextDecoderStream": false, + "TextEncoder": false, + "TextEncoderStream": false, + "TextMetrics": false, + "TransformStream": false, + "TransformStreamDefaultController": false, + "TrustedHTML": false, + "TrustedScript": false, + "TrustedScriptURL": false, + "TrustedTypePolicy": false, + "TrustedTypePolicyFactory": false, + "trustedTypes": false, + "URL": false, + "URLPattern": false, + "URLSearchParams": false, + "USB": false, + "USBAlternateInterface": false, + "USBConfiguration": false, + "USBConnectionEvent": false, + "USBDevice": false, + "USBEndpoint": false, + "USBInterface": false, + "USBInTransferResult": false, + "USBIsochronousInTransferPacket": false, + "USBIsochronousInTransferResult": false, + "USBIsochronousOutTransferPacket": false, + "USBIsochronousOutTransferResult": false, + "USBOutTransferResult": false, + "UserActivation": false, + "VideoColorSpace": false, + "VideoDecoder": false, + "VideoEncoder": false, + "VideoFrame": false, + "WebAssembly": false, + "WebGL2RenderingContext": false, + "WebGLActiveInfo": false, + "WebGLBuffer": false, + "WebGLContextEvent": false, + "WebGLFramebuffer": false, + "WebGLObject": false, + "WebGLProgram": false, + "WebGLQuery": false, + "WebGLRenderbuffer": false, + "WebGLRenderingContext": false, + "WebGLSampler": false, + "WebGLShader": false, + "WebGLShaderPrecisionFormat": false, + "WebGLSync": false, + "WebGLTexture": false, + "WebGLTransformFeedback": false, + "WebGLUniformLocation": false, + "WebGLVertexArrayObject": false, + "webkitRequestFileSystem": false, + "webkitRequestFileSystemSync": false, + "webkitResolveLocalFileSystemSyncURL": false, + "webkitResolveLocalFileSystemURL": false, + "WebSocket": false, + "WebSocketError": false, + "WebSocketStream": false, + "WebTransport": false, + "WebTransportBidirectionalStream": false, + "WebTransportDatagramDuplexStream": false, + "WebTransportError": false, + "WGSLLanguageFeatures": false, + "when": false, + "Worker": false, + "WorkerGlobalScope": false, + "WorkerLocation": false, + "WorkerNavigator": false, + "WritableStream": false, + "WritableStreamDefaultController": false, + "WritableStreamDefaultWriter": false, + "XMLHttpRequest": false, + "XMLHttpRequestEventTarget": false, + "XMLHttpRequestUpload": false + }, + "wsh": { + "ActiveXObject": false, + "CollectGarbage": false, + "Debug": false, + "Enumerator": false, + "GetObject": false, + "RuntimeObject": false, + "ScriptEngine": false, + "ScriptEngineBuildVersion": false, + "ScriptEngineMajorVersion": false, + "ScriptEngineMinorVersion": false, + "VBArray": false, + "WScript": false, + "WSH": false + }, + "yui": { + "YAHOO": false, + "YAHOO_config": false, + "YUI": false, + "YUI_config": false + } +} diff --git a/tools/ui/node_modules/globals/index.d.ts b/tools/ui/node_modules/globals/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2e85e7f4ab35d07962e8e5604c4172194163f939 --- /dev/null +++ b/tools/ui/node_modules/globals/index.d.ts @@ -0,0 +1,3452 @@ +// This file is autogenerated by scripts/generate-types.mjs +// Do NOT modify this file manually + +type GlobalsAmd = { + readonly 'define': false; + readonly 'require': false; +} + +type GlobalsApplescript = { + readonly '$': false; + readonly 'Application': false; + readonly 'Automation': false; + readonly 'console': false; + readonly 'delay': false; + readonly 'Library': false; + readonly 'ObjC': false; + readonly 'ObjectSpecifier': false; + readonly 'Path': false; + readonly 'Progress': false; + readonly 'Ref': false; +} + +type GlobalsAstro = { + readonly 'Astro': false; +} + +type GlobalsAtomtest = { + readonly 'advanceClock': false; + readonly 'atom': false; + readonly 'fakeClearInterval': false; + readonly 'fakeClearTimeout': false; + readonly 'fakeSetInterval': false; + readonly 'fakeSetTimeout': false; + readonly 'resetTimeouts': false; + readonly 'waitsForPromise': false; +} + +type GlobalsBrowser = { + readonly 'AbortController': false; + readonly 'AbortSignal': false; + readonly 'AbsoluteOrientationSensor': false; + readonly 'AbstractRange': false; + readonly 'Accelerometer': false; + readonly 'addEventListener': false; + readonly 'ai': false; + readonly 'AI': false; + readonly 'AICreateMonitor': false; + readonly 'AITextSession': false; + readonly 'alert': false; + readonly 'AnalyserNode': false; + readonly 'Animation': false; + readonly 'AnimationEffect': false; + readonly 'AnimationEvent': false; + readonly 'AnimationPlaybackEvent': false; + readonly 'AnimationTimeline': false; + readonly 'AsyncDisposableStack': false; + readonly 'atob': false; + readonly 'Attr': false; + readonly 'Audio': false; + readonly 'AudioBuffer': false; + readonly 'AudioBufferSourceNode': false; + readonly 'AudioContext': false; + readonly 'AudioData': false; + readonly 'AudioDecoder': false; + readonly 'AudioDestinationNode': false; + readonly 'AudioEncoder': false; + readonly 'AudioListener': false; + readonly 'AudioNode': false; + readonly 'AudioParam': false; + readonly 'AudioParamMap': false; + readonly 'AudioProcessingEvent': false; + readonly 'AudioScheduledSourceNode': false; + readonly 'AudioSinkInfo': false; + readonly 'AudioWorklet': false; + readonly 'AudioWorkletGlobalScope': false; + readonly 'AudioWorkletNode': false; + readonly 'AudioWorkletProcessor': false; + readonly 'AuthenticatorAssertionResponse': false; + readonly 'AuthenticatorAttestationResponse': false; + readonly 'AuthenticatorResponse': false; + readonly 'BackgroundFetchManager': false; + readonly 'BackgroundFetchRecord': false; + readonly 'BackgroundFetchRegistration': false; + readonly 'BarcodeDetector': false; + readonly 'BarProp': false; + readonly 'BaseAudioContext': false; + readonly 'BatteryManager': false; + readonly 'BeforeUnloadEvent': false; + readonly 'BiquadFilterNode': false; + readonly 'Blob': false; + readonly 'BlobEvent': false; + readonly 'Bluetooth': false; + readonly 'BluetoothCharacteristicProperties': false; + readonly 'BluetoothDevice': false; + readonly 'BluetoothRemoteGATTCharacteristic': false; + readonly 'BluetoothRemoteGATTDescriptor': false; + readonly 'BluetoothRemoteGATTServer': false; + readonly 'BluetoothRemoteGATTService': false; + readonly 'BluetoothUUID': false; + readonly 'blur': false; + readonly 'BroadcastChannel': false; + readonly 'BrowserCaptureMediaStreamTrack': false; + readonly 'btoa': false; + readonly 'ByteLengthQueuingStrategy': false; + readonly 'Cache': false; + readonly 'caches': false; + readonly 'CacheStorage': false; + readonly 'cancelAnimationFrame': false; + readonly 'cancelIdleCallback': false; + readonly 'CanvasCaptureMediaStream': false; + readonly 'CanvasCaptureMediaStreamTrack': false; + readonly 'CanvasGradient': false; + readonly 'CanvasPattern': false; + readonly 'CanvasRenderingContext2D': false; + readonly 'CaptureController': false; + readonly 'CaretPosition': false; + readonly 'CDATASection': false; + readonly 'ChannelMergerNode': false; + readonly 'ChannelSplitterNode': false; + readonly 'ChapterInformation': false; + readonly 'CharacterBoundsUpdateEvent': false; + readonly 'CharacterData': false; + readonly 'clearInterval': false; + readonly 'clearTimeout': false; + readonly 'clientInformation': false; + readonly 'Clipboard': false; + readonly 'ClipboardChangeEvent': false; + readonly 'ClipboardEvent': false; + readonly 'ClipboardItem': false; + readonly 'close': false; + readonly 'closed': false; + readonly 'CloseEvent': false; + readonly 'CloseWatcher': false; + readonly 'CommandEvent': false; + readonly 'Comment': false; + readonly 'CompositionEvent': false; + readonly 'CompressionStream': false; + readonly 'confirm': false; + readonly 'console': false; + readonly 'ConstantSourceNode': false; + readonly 'ContentVisibilityAutoStateChangeEvent': false; + readonly 'ConvolverNode': false; + readonly 'CookieChangeEvent': false; + readonly 'CookieDeprecationLabel': false; + readonly 'cookieStore': false; + readonly 'CookieStore': false; + readonly 'CookieStoreManager': false; + readonly 'CountQueuingStrategy': false; + readonly 'createImageBitmap': false; + readonly 'CreateMonitor': false; + readonly 'Credential': false; + readonly 'credentialless': false; + readonly 'CredentialsContainer': false; + readonly 'CropTarget': false; + readonly 'crossOriginIsolated': false; + readonly 'crypto': false; + readonly 'Crypto': false; + readonly 'CryptoKey': false; + readonly 'CSPViolationReportBody': false; + readonly 'CSS': false; + readonly 'CSSAnimation': false; + readonly 'CSSConditionRule': false; + readonly 'CSSContainerRule': false; + readonly 'CSSCounterStyleRule': false; + readonly 'CSSFontFaceRule': false; + readonly 'CSSFontFeatureValuesRule': false; + readonly 'CSSFontPaletteValuesRule': false; + readonly 'CSSFunctionDeclarations': false; + readonly 'CSSFunctionDescriptors': false; + readonly 'CSSFunctionRule': false; + readonly 'CSSGroupingRule': false; + readonly 'CSSImageValue': false; + readonly 'CSSImportRule': false; + readonly 'CSSKeyframeRule': false; + readonly 'CSSKeyframesRule': false; + readonly 'CSSKeywordValue': false; + readonly 'CSSLayerBlockRule': false; + readonly 'CSSLayerStatementRule': false; + readonly 'CSSMarginRule': false; + readonly 'CSSMathClamp': false; + readonly 'CSSMathInvert': false; + readonly 'CSSMathMax': false; + readonly 'CSSMathMin': false; + readonly 'CSSMathNegate': false; + readonly 'CSSMathProduct': false; + readonly 'CSSMathSum': false; + readonly 'CSSMathValue': false; + readonly 'CSSMatrixComponent': false; + readonly 'CSSMediaRule': false; + readonly 'CSSNamespaceRule': false; + readonly 'CSSNestedDeclarations': false; + readonly 'CSSNumericArray': false; + readonly 'CSSNumericValue': false; + readonly 'CSSPageDescriptors': false; + readonly 'CSSPageRule': false; + readonly 'CSSPerspective': false; + readonly 'CSSPositionTryDescriptors': false; + readonly 'CSSPositionTryRule': false; + readonly 'CSSPositionValue': false; + readonly 'CSSPropertyRule': false; + readonly 'CSSRotate': false; + readonly 'CSSRule': false; + readonly 'CSSRuleList': false; + readonly 'CSSScale': false; + readonly 'CSSScopeRule': false; + readonly 'CSSSkew': false; + readonly 'CSSSkewX': false; + readonly 'CSSSkewY': false; + readonly 'CSSStartingStyleRule': false; + readonly 'CSSStyleDeclaration': false; + readonly 'CSSStyleRule': false; + readonly 'CSSStyleSheet': false; + readonly 'CSSStyleValue': false; + readonly 'CSSSupportsRule': false; + readonly 'CSSTransformComponent': false; + readonly 'CSSTransformValue': false; + readonly 'CSSTransition': false; + readonly 'CSSTranslate': false; + readonly 'CSSUnitValue': false; + readonly 'CSSUnparsedValue': false; + readonly 'CSSVariableReferenceValue': false; + readonly 'CSSViewTransitionRule': false; + readonly 'currentFrame': false; + readonly 'currentTime': false; + readonly 'CustomElementRegistry': false; + readonly 'customElements': false; + readonly 'CustomEvent': false; + readonly 'CustomStateSet': false; + readonly 'DataTransfer': false; + readonly 'DataTransferItem': false; + readonly 'DataTransferItemList': false; + readonly 'DecompressionStream': false; + readonly 'DelayNode': false; + readonly 'DelegatedInkTrailPresenter': false; + readonly 'DeviceMotionEvent': false; + readonly 'DeviceMotionEventAcceleration': false; + readonly 'DeviceMotionEventRotationRate': false; + readonly 'DeviceOrientationEvent': false; + readonly 'devicePixelRatio': false; + readonly 'DevicePosture': false; + readonly 'DigitalCredential': false; + readonly 'dispatchEvent': false; + readonly 'DisposableStack': false; + readonly 'document': false; + readonly 'Document': false; + readonly 'DocumentFragment': false; + readonly 'documentPictureInPicture': false; + readonly 'DocumentPictureInPicture': false; + readonly 'DocumentPictureInPictureEvent': false; + readonly 'DocumentTimeline': false; + readonly 'DocumentType': false; + readonly 'DOMError': false; + readonly 'DOMException': false; + readonly 'DOMImplementation': false; + readonly 'DOMMatrix': false; + readonly 'DOMMatrixReadOnly': false; + readonly 'DOMParser': false; + readonly 'DOMPoint': false; + readonly 'DOMPointReadOnly': false; + readonly 'DOMQuad': false; + readonly 'DOMRect': false; + readonly 'DOMRectList': false; + readonly 'DOMRectReadOnly': false; + readonly 'DOMStringList': false; + readonly 'DOMStringMap': false; + readonly 'DOMTokenList': false; + readonly 'DragEvent': false; + readonly 'DynamicsCompressorNode': false; + readonly 'EditContext': false; + readonly 'Element': false; + readonly 'ElementInternals': false; + readonly 'EncodedAudioChunk': false; + readonly 'EncodedVideoChunk': false; + readonly 'ErrorEvent': false; + readonly 'event': false; + readonly 'Event': false; + readonly 'EventCounts': false; + readonly 'EventSource': false; + readonly 'EventTarget': false; + readonly 'external': false; + readonly 'External': false; + readonly 'EyeDropper': false; + readonly 'FeaturePolicy': false; + readonly 'FederatedCredential': false; + readonly 'fence': false; + readonly 'Fence': false; + readonly 'FencedFrameConfig': false; + readonly 'fetch': false; + readonly 'fetchLater': false; + readonly 'FetchLaterResult': false; + readonly 'File': false; + readonly 'FileList': false; + readonly 'FileReader': false; + readonly 'FileSystem': false; + readonly 'FileSystemDirectoryEntry': false; + readonly 'FileSystemDirectoryHandle': false; + readonly 'FileSystemDirectoryReader': false; + readonly 'FileSystemEntry': false; + readonly 'FileSystemFileEntry': false; + readonly 'FileSystemFileHandle': false; + readonly 'FileSystemHandle': false; + readonly 'FileSystemObserver': false; + readonly 'FileSystemWritableFileStream': false; + readonly 'find': false; + readonly 'focus': false; + readonly 'FocusEvent': false; + readonly 'FontData': false; + readonly 'FontFace': false; + readonly 'FontFaceSet': false; + readonly 'FontFaceSetLoadEvent': false; + readonly 'FormData': false; + readonly 'FormDataEvent': false; + readonly 'FragmentDirective': false; + readonly 'frameElement': false; + readonly 'frames': false; + readonly 'GainNode': false; + readonly 'Gamepad': false; + readonly 'GamepadAxisMoveEvent': false; + readonly 'GamepadButton': false; + readonly 'GamepadButtonEvent': false; + readonly 'GamepadEvent': false; + readonly 'GamepadHapticActuator': false; + readonly 'GamepadPose': false; + readonly 'Geolocation': false; + readonly 'GeolocationCoordinates': false; + readonly 'GeolocationPosition': false; + readonly 'GeolocationPositionError': false; + readonly 'getComputedStyle': false; + readonly 'getScreenDetails': false; + readonly 'getSelection': false; + readonly 'GPU': false; + readonly 'GPUAdapter': false; + readonly 'GPUAdapterInfo': false; + readonly 'GPUBindGroup': false; + readonly 'GPUBindGroupLayout': false; + readonly 'GPUBuffer': false; + readonly 'GPUBufferUsage': false; + readonly 'GPUCanvasContext': false; + readonly 'GPUColorWrite': false; + readonly 'GPUCommandBuffer': false; + readonly 'GPUCommandEncoder': false; + readonly 'GPUCompilationInfo': false; + readonly 'GPUCompilationMessage': false; + readonly 'GPUComputePassEncoder': false; + readonly 'GPUComputePipeline': false; + readonly 'GPUDevice': false; + readonly 'GPUDeviceLostInfo': false; + readonly 'GPUError': false; + readonly 'GPUExternalTexture': false; + readonly 'GPUInternalError': false; + readonly 'GPUMapMode': false; + readonly 'GPUOutOfMemoryError': false; + readonly 'GPUPipelineError': false; + readonly 'GPUPipelineLayout': false; + readonly 'GPUQuerySet': false; + readonly 'GPUQueue': false; + readonly 'GPURenderBundle': false; + readonly 'GPURenderBundleEncoder': false; + readonly 'GPURenderPassEncoder': false; + readonly 'GPURenderPipeline': false; + readonly 'GPUSampler': false; + readonly 'GPUShaderModule': false; + readonly 'GPUShaderStage': false; + readonly 'GPUSupportedFeatures': false; + readonly 'GPUSupportedLimits': false; + readonly 'GPUTexture': false; + readonly 'GPUTextureUsage': false; + readonly 'GPUTextureView': false; + readonly 'GPUUncapturedErrorEvent': false; + readonly 'GPUValidationError': false; + readonly 'GravitySensor': false; + readonly 'Gyroscope': false; + readonly 'HashChangeEvent': false; + readonly 'Headers': false; + readonly 'HID': false; + readonly 'HIDConnectionEvent': false; + readonly 'HIDDevice': false; + readonly 'HIDInputReportEvent': false; + readonly 'Highlight': false; + readonly 'HighlightRegistry': false; + readonly 'history': false; + readonly 'History': false; + readonly 'HTMLAllCollection': false; + readonly 'HTMLAnchorElement': false; + readonly 'HTMLAreaElement': false; + readonly 'HTMLAudioElement': false; + readonly 'HTMLBaseElement': false; + readonly 'HTMLBodyElement': false; + readonly 'HTMLBRElement': false; + readonly 'HTMLButtonElement': false; + readonly 'HTMLCanvasElement': false; + readonly 'HTMLCollection': false; + readonly 'HTMLDataElement': false; + readonly 'HTMLDataListElement': false; + readonly 'HTMLDetailsElement': false; + readonly 'HTMLDialogElement': false; + readonly 'HTMLDirectoryElement': false; + readonly 'HTMLDivElement': false; + readonly 'HTMLDListElement': false; + readonly 'HTMLDocument': false; + readonly 'HTMLElement': false; + readonly 'HTMLEmbedElement': false; + readonly 'HTMLFencedFrameElement': false; + readonly 'HTMLFieldSetElement': false; + readonly 'HTMLFontElement': false; + readonly 'HTMLFormControlsCollection': false; + readonly 'HTMLFormElement': false; + readonly 'HTMLFrameElement': false; + readonly 'HTMLFrameSetElement': false; + readonly 'HTMLHeadElement': false; + readonly 'HTMLHeadingElement': false; + readonly 'HTMLHRElement': false; + readonly 'HTMLHtmlElement': false; + readonly 'HTMLIFrameElement': false; + readonly 'HTMLImageElement': false; + readonly 'HTMLInputElement': false; + readonly 'HTMLLabelElement': false; + readonly 'HTMLLegendElement': false; + readonly 'HTMLLIElement': false; + readonly 'HTMLLinkElement': false; + readonly 'HTMLMapElement': false; + readonly 'HTMLMarqueeElement': false; + readonly 'HTMLMediaElement': false; + readonly 'HTMLMenuElement': false; + readonly 'HTMLMetaElement': false; + readonly 'HTMLMeterElement': false; + readonly 'HTMLModElement': false; + readonly 'HTMLObjectElement': false; + readonly 'HTMLOListElement': false; + readonly 'HTMLOptGroupElement': false; + readonly 'HTMLOptionElement': false; + readonly 'HTMLOptionsCollection': false; + readonly 'HTMLOutputElement': false; + readonly 'HTMLParagraphElement': false; + readonly 'HTMLParamElement': false; + readonly 'HTMLPictureElement': false; + readonly 'HTMLPreElement': false; + readonly 'HTMLProgressElement': false; + readonly 'HTMLQuoteElement': false; + readonly 'HTMLScriptElement': false; + readonly 'HTMLSelectedContentElement': false; + readonly 'HTMLSelectElement': false; + readonly 'HTMLSlotElement': false; + readonly 'HTMLSourceElement': false; + readonly 'HTMLSpanElement': false; + readonly 'HTMLStyleElement': false; + readonly 'HTMLTableCaptionElement': false; + readonly 'HTMLTableCellElement': false; + readonly 'HTMLTableColElement': false; + readonly 'HTMLTableElement': false; + readonly 'HTMLTableRowElement': false; + readonly 'HTMLTableSectionElement': false; + readonly 'HTMLTemplateElement': false; + readonly 'HTMLTextAreaElement': false; + readonly 'HTMLTimeElement': false; + readonly 'HTMLTitleElement': false; + readonly 'HTMLTrackElement': false; + readonly 'HTMLUListElement': false; + readonly 'HTMLUnknownElement': false; + readonly 'HTMLVideoElement': false; + readonly 'IDBCursor': false; + readonly 'IDBCursorWithValue': false; + readonly 'IDBDatabase': false; + readonly 'IDBFactory': false; + readonly 'IDBIndex': false; + readonly 'IDBKeyRange': false; + readonly 'IDBObjectStore': false; + readonly 'IDBOpenDBRequest': false; + readonly 'IDBRecord': false; + readonly 'IDBRequest': false; + readonly 'IDBTransaction': false; + readonly 'IDBVersionChangeEvent': false; + readonly 'IdentityCredential': false; + readonly 'IdentityCredentialError': false; + readonly 'IdentityProvider': false; + readonly 'IdleDeadline': false; + readonly 'IdleDetector': false; + readonly 'IIRFilterNode': false; + readonly 'Image': false; + readonly 'ImageBitmap': false; + readonly 'ImageBitmapRenderingContext': false; + readonly 'ImageCapture': false; + readonly 'ImageData': false; + readonly 'ImageDecoder': false; + readonly 'ImageTrack': false; + readonly 'ImageTrackList': false; + readonly 'indexedDB': false; + readonly 'Ink': false; + readonly 'innerHeight': false; + readonly 'innerWidth': false; + readonly 'InputDeviceCapabilities': false; + readonly 'InputDeviceInfo': false; + readonly 'InputEvent': false; + readonly 'IntegrityViolationReportBody': false; + readonly 'InterestEvent': false; + readonly 'IntersectionObserver': false; + readonly 'IntersectionObserverEntry': false; + readonly 'isSecureContext': false; + readonly 'Keyboard': false; + readonly 'KeyboardEvent': false; + readonly 'KeyboardLayoutMap': false; + readonly 'KeyframeEffect': false; + readonly 'LanguageDetector': false; + readonly 'LargestContentfulPaint': false; + readonly 'LaunchParams': false; + readonly 'launchQueue': false; + readonly 'LaunchQueue': false; + readonly 'LayoutShift': false; + readonly 'LayoutShiftAttribution': false; + readonly 'length': false; + readonly 'LinearAccelerationSensor': false; + readonly 'localStorage': false; + readonly 'location': true; + readonly 'Location': false; + readonly 'locationbar': false; + readonly 'Lock': false; + readonly 'LockManager': false; + readonly 'matchMedia': false; + readonly 'MathMLElement': false; + readonly 'MediaCapabilities': false; + readonly 'MediaCapabilitiesInfo': false; + readonly 'MediaDeviceInfo': false; + readonly 'MediaDevices': false; + readonly 'MediaElementAudioSourceNode': false; + readonly 'MediaEncryptedEvent': false; + readonly 'MediaError': false; + readonly 'MediaKeyError': false; + readonly 'MediaKeyMessageEvent': false; + readonly 'MediaKeys': false; + readonly 'MediaKeySession': false; + readonly 'MediaKeyStatusMap': false; + readonly 'MediaKeySystemAccess': false; + readonly 'MediaList': false; + readonly 'MediaMetadata': false; + readonly 'MediaQueryList': false; + readonly 'MediaQueryListEvent': false; + readonly 'MediaRecorder': false; + readonly 'MediaRecorderErrorEvent': false; + readonly 'MediaSession': false; + readonly 'MediaSource': false; + readonly 'MediaSourceHandle': false; + readonly 'MediaStream': false; + readonly 'MediaStreamAudioDestinationNode': false; + readonly 'MediaStreamAudioSourceNode': false; + readonly 'MediaStreamEvent': false; + readonly 'MediaStreamTrack': false; + readonly 'MediaStreamTrackAudioSourceNode': false; + readonly 'MediaStreamTrackAudioStats': false; + readonly 'MediaStreamTrackEvent': false; + readonly 'MediaStreamTrackGenerator': false; + readonly 'MediaStreamTrackProcessor': false; + readonly 'MediaStreamTrackVideoStats': false; + readonly 'menubar': false; + readonly 'MessageChannel': false; + readonly 'MessageEvent': false; + readonly 'MessagePort': false; + readonly 'MIDIAccess': false; + readonly 'MIDIConnectionEvent': false; + readonly 'MIDIInput': false; + readonly 'MIDIInputMap': false; + readonly 'MIDIMessageEvent': false; + readonly 'MIDIOutput': false; + readonly 'MIDIOutputMap': false; + readonly 'MIDIPort': false; + readonly 'MimeType': false; + readonly 'MimeTypeArray': false; + readonly 'model': false; + readonly 'ModelGenericSession': false; + readonly 'ModelManager': false; + readonly 'MouseEvent': false; + readonly 'moveBy': false; + readonly 'moveTo': false; + readonly 'MutationEvent': false; + readonly 'MutationObserver': false; + readonly 'MutationRecord': false; + readonly 'name': false; + readonly 'NamedNodeMap': false; + readonly 'NavigateEvent': false; + readonly 'navigation': false; + readonly 'Navigation': false; + readonly 'NavigationActivation': false; + readonly 'NavigationCurrentEntryChangeEvent': false; + readonly 'NavigationDestination': false; + readonly 'NavigationHistoryEntry': false; + readonly 'NavigationPrecommitController': false; + readonly 'NavigationPreloadManager': false; + readonly 'NavigationTransition': false; + readonly 'navigator': false; + readonly 'Navigator': false; + readonly 'NavigatorLogin': false; + readonly 'NavigatorManagedData': false; + readonly 'NavigatorUAData': false; + readonly 'NetworkInformation': false; + readonly 'Node': false; + readonly 'NodeFilter': false; + readonly 'NodeIterator': false; + readonly 'NodeList': false; + readonly 'Notification': false; + readonly 'NotifyPaintEvent': false; + readonly 'NotRestoredReasonDetails': false; + readonly 'NotRestoredReasons': false; + readonly 'Observable': false; + readonly 'OfflineAudioCompletionEvent': false; + readonly 'OfflineAudioContext': false; + readonly 'offscreenBuffering': false; + readonly 'OffscreenCanvas': false; + readonly 'OffscreenCanvasRenderingContext2D': false; + readonly 'onabort': true; + readonly 'onafterprint': true; + readonly 'onanimationcancel': true; + readonly 'onanimationend': true; + readonly 'onanimationiteration': true; + readonly 'onanimationstart': true; + readonly 'onappinstalled': true; + readonly 'onauxclick': true; + readonly 'onbeforeinput': true; + readonly 'onbeforeinstallprompt': true; + readonly 'onbeforematch': true; + readonly 'onbeforeprint': true; + readonly 'onbeforetoggle': true; + readonly 'onbeforeunload': true; + readonly 'onbeforexrselect': true; + readonly 'onblur': true; + readonly 'oncancel': true; + readonly 'oncanplay': true; + readonly 'oncanplaythrough': true; + readonly 'onchange': true; + readonly 'onclick': true; + readonly 'onclose': true; + readonly 'oncommand': true; + readonly 'oncontentvisibilityautostatechange': true; + readonly 'oncontextlost': true; + readonly 'oncontextmenu': true; + readonly 'oncontextrestored': true; + readonly 'oncopy': true; + readonly 'oncuechange': true; + readonly 'oncut': true; + readonly 'ondblclick': true; + readonly 'ondevicemotion': true; + readonly 'ondeviceorientation': true; + readonly 'ondeviceorientationabsolute': true; + readonly 'ondrag': true; + readonly 'ondragend': true; + readonly 'ondragenter': true; + readonly 'ondragleave': true; + readonly 'ondragover': true; + readonly 'ondragstart': true; + readonly 'ondrop': true; + readonly 'ondurationchange': true; + readonly 'onemptied': true; + readonly 'onended': true; + readonly 'onerror': true; + readonly 'onfocus': true; + readonly 'onformdata': true; + readonly 'ongamepadconnected': true; + readonly 'ongamepaddisconnected': true; + readonly 'ongotpointercapture': true; + readonly 'onhashchange': true; + readonly 'oninput': true; + readonly 'oninvalid': true; + readonly 'onkeydown': true; + readonly 'onkeypress': true; + readonly 'onkeyup': true; + readonly 'onlanguagechange': true; + readonly 'onload': true; + readonly 'onloadeddata': true; + readonly 'onloadedmetadata': true; + readonly 'onloadstart': true; + readonly 'onlostpointercapture': true; + readonly 'onmessage': true; + readonly 'onmessageerror': true; + readonly 'onmousedown': true; + readonly 'onmouseenter': true; + readonly 'onmouseleave': true; + readonly 'onmousemove': true; + readonly 'onmouseout': true; + readonly 'onmouseover': true; + readonly 'onmouseup': true; + readonly 'onmousewheel': true; + readonly 'onoffline': true; + readonly 'ononline': true; + readonly 'onpagehide': true; + readonly 'onpagereveal': true; + readonly 'onpageshow': true; + readonly 'onpageswap': true; + readonly 'onpaste': true; + readonly 'onpause': true; + readonly 'onplay': true; + readonly 'onplaying': true; + readonly 'onpointercancel': true; + readonly 'onpointerdown': true; + readonly 'onpointerenter': true; + readonly 'onpointerleave': true; + readonly 'onpointermove': true; + readonly 'onpointerout': true; + readonly 'onpointerover': true; + readonly 'onpointerrawupdate': true; + readonly 'onpointerup': true; + readonly 'onpopstate': true; + readonly 'onprogress': true; + readonly 'onratechange': true; + readonly 'onrejectionhandled': true; + readonly 'onreset': true; + readonly 'onresize': true; + readonly 'onscroll': true; + readonly 'onscrollend': true; + readonly 'onscrollsnapchange': true; + readonly 'onscrollsnapchanging': true; + readonly 'onsearch': true; + readonly 'onsecuritypolicyviolation': true; + readonly 'onseeked': true; + readonly 'onseeking': true; + readonly 'onselect': true; + readonly 'onselectionchange': true; + readonly 'onselectstart': true; + readonly 'onslotchange': true; + readonly 'onstalled': true; + readonly 'onstorage': true; + readonly 'onsubmit': true; + readonly 'onsuspend': true; + readonly 'ontimeupdate': true; + readonly 'ontoggle': true; + readonly 'ontransitioncancel': true; + readonly 'ontransitionend': true; + readonly 'ontransitionrun': true; + readonly 'ontransitionstart': true; + readonly 'onunhandledrejection': true; + readonly 'onunload': true; + readonly 'onvolumechange': true; + readonly 'onwaiting': true; + readonly 'onwheel': true; + readonly 'open': false; + readonly 'opener': false; + readonly 'Option': false; + readonly 'OrientationSensor': false; + readonly 'origin': false; + readonly 'originAgentCluster': false; + readonly 'OscillatorNode': false; + readonly 'OTPCredential': false; + readonly 'outerHeight': false; + readonly 'outerWidth': false; + readonly 'OverconstrainedError': false; + readonly 'PageRevealEvent': false; + readonly 'PageSwapEvent': false; + readonly 'PageTransitionEvent': false; + readonly 'pageXOffset': false; + readonly 'pageYOffset': false; + readonly 'PannerNode': false; + readonly 'parent': false; + readonly 'PasswordCredential': false; + readonly 'Path2D': false; + readonly 'PaymentAddress': false; + readonly 'PaymentManager': false; + readonly 'PaymentMethodChangeEvent': false; + readonly 'PaymentRequest': false; + readonly 'PaymentRequestUpdateEvent': false; + readonly 'PaymentResponse': false; + readonly 'performance': false; + readonly 'Performance': false; + readonly 'PerformanceElementTiming': false; + readonly 'PerformanceEntry': false; + readonly 'PerformanceEventTiming': false; + readonly 'PerformanceLongAnimationFrameTiming': false; + readonly 'PerformanceLongTaskTiming': false; + readonly 'PerformanceMark': false; + readonly 'PerformanceMeasure': false; + readonly 'PerformanceNavigation': false; + readonly 'PerformanceNavigationTiming': false; + readonly 'PerformanceObserver': false; + readonly 'PerformanceObserverEntryList': false; + readonly 'PerformancePaintTiming': false; + readonly 'PerformanceResourceTiming': false; + readonly 'PerformanceScriptTiming': false; + readonly 'PerformanceServerTiming': false; + readonly 'PerformanceTiming': false; + readonly 'PeriodicSyncManager': false; + readonly 'PeriodicWave': false; + readonly 'Permissions': false; + readonly 'PermissionStatus': false; + readonly 'PERSISTENT': false; + readonly 'personalbar': false; + readonly 'PictureInPictureEvent': false; + readonly 'PictureInPictureWindow': false; + readonly 'Plugin': false; + readonly 'PluginArray': false; + readonly 'PointerEvent': false; + readonly 'PopStateEvent': false; + readonly 'postMessage': false; + readonly 'Presentation': false; + readonly 'PresentationAvailability': false; + readonly 'PresentationConnection': false; + readonly 'PresentationConnectionAvailableEvent': false; + readonly 'PresentationConnectionCloseEvent': false; + readonly 'PresentationConnectionList': false; + readonly 'PresentationReceiver': false; + readonly 'PresentationRequest': false; + readonly 'PressureObserver': false; + readonly 'PressureRecord': false; + readonly 'print': false; + readonly 'ProcessingInstruction': false; + readonly 'Profiler': false; + readonly 'ProgressEvent': false; + readonly 'PromiseRejectionEvent': false; + readonly 'prompt': false; + readonly 'ProtectedAudience': false; + readonly 'PublicKeyCredential': false; + readonly 'PushManager': false; + readonly 'PushSubscription': false; + readonly 'PushSubscriptionOptions': false; + readonly 'queryLocalFonts': false; + readonly 'queueMicrotask': false; + readonly 'QuotaExceededError': false; + readonly 'RadioNodeList': false; + readonly 'Range': false; + readonly 'ReadableByteStreamController': false; + readonly 'ReadableStream': false; + readonly 'ReadableStreamBYOBReader': false; + readonly 'ReadableStreamBYOBRequest': false; + readonly 'ReadableStreamDefaultController': false; + readonly 'ReadableStreamDefaultReader': false; + readonly 'registerProcessor': false; + readonly 'RelativeOrientationSensor': false; + readonly 'RemotePlayback': false; + readonly 'removeEventListener': false; + readonly 'ReportBody': false; + readonly 'reportError': false; + readonly 'ReportingObserver': false; + readonly 'Request': false; + readonly 'requestAnimationFrame': false; + readonly 'requestIdleCallback': false; + readonly 'resizeBy': false; + readonly 'ResizeObserver': false; + readonly 'ResizeObserverEntry': false; + readonly 'ResizeObserverSize': false; + readonly 'resizeTo': false; + readonly 'Response': false; + readonly 'RestrictionTarget': false; + readonly 'RTCCertificate': false; + readonly 'RTCDataChannel': false; + readonly 'RTCDataChannelEvent': false; + readonly 'RTCDtlsTransport': false; + readonly 'RTCDTMFSender': false; + readonly 'RTCDTMFToneChangeEvent': false; + readonly 'RTCEncodedAudioFrame': false; + readonly 'RTCEncodedVideoFrame': false; + readonly 'RTCError': false; + readonly 'RTCErrorEvent': false; + readonly 'RTCIceCandidate': false; + readonly 'RTCIceTransport': false; + readonly 'RTCPeerConnection': false; + readonly 'RTCPeerConnectionIceErrorEvent': false; + readonly 'RTCPeerConnectionIceEvent': false; + readonly 'RTCRtpReceiver': false; + readonly 'RTCRtpScriptTransform': false; + readonly 'RTCRtpSender': false; + readonly 'RTCRtpTransceiver': false; + readonly 'RTCSctpTransport': false; + readonly 'RTCSessionDescription': false; + readonly 'RTCStatsReport': false; + readonly 'RTCTrackEvent': false; + readonly 'sampleRate': false; + readonly 'scheduler': false; + readonly 'Scheduler': false; + readonly 'Scheduling': false; + readonly 'screen': false; + readonly 'Screen': false; + readonly 'ScreenDetailed': false; + readonly 'ScreenDetails': false; + readonly 'screenLeft': false; + readonly 'ScreenOrientation': false; + readonly 'screenTop': false; + readonly 'screenX': false; + readonly 'screenY': false; + readonly 'ScriptProcessorNode': false; + readonly 'scroll': false; + readonly 'scrollbars': false; + readonly 'scrollBy': false; + readonly 'ScrollTimeline': false; + readonly 'scrollTo': false; + readonly 'scrollX': false; + readonly 'scrollY': false; + readonly 'SecurityPolicyViolationEvent': false; + readonly 'Selection': false; + readonly 'self': false; + readonly 'Sensor': false; + readonly 'SensorErrorEvent': false; + readonly 'Serial': false; + readonly 'SerialPort': false; + readonly 'ServiceWorker': false; + readonly 'ServiceWorkerContainer': false; + readonly 'ServiceWorkerRegistration': false; + readonly 'sessionStorage': false; + readonly 'setInterval': false; + readonly 'setTimeout': false; + readonly 'ShadowRoot': false; + readonly 'sharedStorage': false; + readonly 'SharedStorage': false; + readonly 'SharedStorageAppendMethod': false; + readonly 'SharedStorageClearMethod': false; + readonly 'SharedStorageDeleteMethod': false; + readonly 'SharedStorageModifierMethod': false; + readonly 'SharedStorageSetMethod': false; + readonly 'SharedStorageWorklet': false; + readonly 'SharedWorker': false; + readonly 'showDirectoryPicker': false; + readonly 'showOpenFilePicker': false; + readonly 'showSaveFilePicker': false; + readonly 'SnapEvent': false; + readonly 'SourceBuffer': false; + readonly 'SourceBufferList': false; + readonly 'SpeechGrammar': false; + readonly 'SpeechGrammarList': false; + readonly 'SpeechRecognition': false; + readonly 'SpeechRecognitionErrorEvent': false; + readonly 'SpeechRecognitionEvent': false; + readonly 'SpeechRecognitionPhrase': false; + readonly 'speechSynthesis': false; + readonly 'SpeechSynthesis': false; + readonly 'SpeechSynthesisErrorEvent': false; + readonly 'SpeechSynthesisEvent': false; + readonly 'SpeechSynthesisUtterance': false; + readonly 'SpeechSynthesisVoice': false; + readonly 'StaticRange': false; + readonly 'status': false; + readonly 'statusbar': false; + readonly 'StereoPannerNode': false; + readonly 'stop': false; + readonly 'Storage': false; + readonly 'StorageBucket': false; + readonly 'StorageBucketManager': false; + readonly 'StorageEvent': false; + readonly 'StorageManager': false; + readonly 'structuredClone': false; + readonly 'styleMedia': false; + readonly 'StylePropertyMap': false; + readonly 'StylePropertyMapReadOnly': false; + readonly 'StyleSheet': false; + readonly 'StyleSheetList': false; + readonly 'SubmitEvent': false; + readonly 'Subscriber': false; + readonly 'SubtleCrypto': false; + readonly 'Summarizer': false; + readonly 'SuppressedError': false; + readonly 'SVGAElement': false; + readonly 'SVGAngle': false; + readonly 'SVGAnimatedAngle': false; + readonly 'SVGAnimatedBoolean': false; + readonly 'SVGAnimatedEnumeration': false; + readonly 'SVGAnimatedInteger': false; + readonly 'SVGAnimatedLength': false; + readonly 'SVGAnimatedLengthList': false; + readonly 'SVGAnimatedNumber': false; + readonly 'SVGAnimatedNumberList': false; + readonly 'SVGAnimatedPreserveAspectRatio': false; + readonly 'SVGAnimatedRect': false; + readonly 'SVGAnimatedString': false; + readonly 'SVGAnimatedTransformList': false; + readonly 'SVGAnimateElement': false; + readonly 'SVGAnimateMotionElement': false; + readonly 'SVGAnimateTransformElement': false; + readonly 'SVGAnimationElement': false; + readonly 'SVGCircleElement': false; + readonly 'SVGClipPathElement': false; + readonly 'SVGComponentTransferFunctionElement': false; + readonly 'SVGDefsElement': false; + readonly 'SVGDescElement': false; + readonly 'SVGElement': false; + readonly 'SVGEllipseElement': false; + readonly 'SVGFEBlendElement': false; + readonly 'SVGFEColorMatrixElement': false; + readonly 'SVGFEComponentTransferElement': false; + readonly 'SVGFECompositeElement': false; + readonly 'SVGFEConvolveMatrixElement': false; + readonly 'SVGFEDiffuseLightingElement': false; + readonly 'SVGFEDisplacementMapElement': false; + readonly 'SVGFEDistantLightElement': false; + readonly 'SVGFEDropShadowElement': false; + readonly 'SVGFEFloodElement': false; + readonly 'SVGFEFuncAElement': false; + readonly 'SVGFEFuncBElement': false; + readonly 'SVGFEFuncGElement': false; + readonly 'SVGFEFuncRElement': false; + readonly 'SVGFEGaussianBlurElement': false; + readonly 'SVGFEImageElement': false; + readonly 'SVGFEMergeElement': false; + readonly 'SVGFEMergeNodeElement': false; + readonly 'SVGFEMorphologyElement': false; + readonly 'SVGFEOffsetElement': false; + readonly 'SVGFEPointLightElement': false; + readonly 'SVGFESpecularLightingElement': false; + readonly 'SVGFESpotLightElement': false; + readonly 'SVGFETileElement': false; + readonly 'SVGFETurbulenceElement': false; + readonly 'SVGFilterElement': false; + readonly 'SVGForeignObjectElement': false; + readonly 'SVGGElement': false; + readonly 'SVGGeometryElement': false; + readonly 'SVGGradientElement': false; + readonly 'SVGGraphicsElement': false; + readonly 'SVGImageElement': false; + readonly 'SVGLength': false; + readonly 'SVGLengthList': false; + readonly 'SVGLinearGradientElement': false; + readonly 'SVGLineElement': false; + readonly 'SVGMarkerElement': false; + readonly 'SVGMaskElement': false; + readonly 'SVGMatrix': false; + readonly 'SVGMetadataElement': false; + readonly 'SVGMPathElement': false; + readonly 'SVGNumber': false; + readonly 'SVGNumberList': false; + readonly 'SVGPathElement': false; + readonly 'SVGPatternElement': false; + readonly 'SVGPoint': false; + readonly 'SVGPointList': false; + readonly 'SVGPolygonElement': false; + readonly 'SVGPolylineElement': false; + readonly 'SVGPreserveAspectRatio': false; + readonly 'SVGRadialGradientElement': false; + readonly 'SVGRect': false; + readonly 'SVGRectElement': false; + readonly 'SVGScriptElement': false; + readonly 'SVGSetElement': false; + readonly 'SVGStopElement': false; + readonly 'SVGStringList': false; + readonly 'SVGStyleElement': false; + readonly 'SVGSVGElement': false; + readonly 'SVGSwitchElement': false; + readonly 'SVGSymbolElement': false; + readonly 'SVGTextContentElement': false; + readonly 'SVGTextElement': false; + readonly 'SVGTextPathElement': false; + readonly 'SVGTextPositioningElement': false; + readonly 'SVGTitleElement': false; + readonly 'SVGTransform': false; + readonly 'SVGTransformList': false; + readonly 'SVGTSpanElement': false; + readonly 'SVGUnitTypes': false; + readonly 'SVGUseElement': false; + readonly 'SVGViewElement': false; + readonly 'SyncManager': false; + readonly 'TaskAttributionTiming': false; + readonly 'TaskController': false; + readonly 'TaskPriorityChangeEvent': false; + readonly 'TaskSignal': false; + readonly 'TEMPORARY': false; + readonly 'Text': false; + readonly 'TextDecoder': false; + readonly 'TextDecoderStream': false; + readonly 'TextEncoder': false; + readonly 'TextEncoderStream': false; + readonly 'TextEvent': false; + readonly 'TextFormat': false; + readonly 'TextFormatUpdateEvent': false; + readonly 'TextMetrics': false; + readonly 'TextTrack': false; + readonly 'TextTrackCue': false; + readonly 'TextTrackCueList': false; + readonly 'TextTrackList': false; + readonly 'TextUpdateEvent': false; + readonly 'TimeEvent': false; + readonly 'TimeRanges': false; + readonly 'ToggleEvent': false; + readonly 'toolbar': false; + readonly 'top': false; + readonly 'Touch': false; + readonly 'TouchEvent': false; + readonly 'TouchList': false; + readonly 'TrackEvent': false; + readonly 'TransformStream': false; + readonly 'TransformStreamDefaultController': false; + readonly 'TransitionEvent': false; + readonly 'Translator': false; + readonly 'TreeWalker': false; + readonly 'TrustedHTML': false; + readonly 'TrustedScript': false; + readonly 'TrustedScriptURL': false; + readonly 'TrustedTypePolicy': false; + readonly 'TrustedTypePolicyFactory': false; + readonly 'trustedTypes': false; + readonly 'UIEvent': false; + readonly 'URL': false; + readonly 'URLPattern': false; + readonly 'URLSearchParams': false; + readonly 'USB': false; + readonly 'USBAlternateInterface': false; + readonly 'USBConfiguration': false; + readonly 'USBConnectionEvent': false; + readonly 'USBDevice': false; + readonly 'USBEndpoint': false; + readonly 'USBInterface': false; + readonly 'USBInTransferResult': false; + readonly 'USBIsochronousInTransferPacket': false; + readonly 'USBIsochronousInTransferResult': false; + readonly 'USBIsochronousOutTransferPacket': false; + readonly 'USBIsochronousOutTransferResult': false; + readonly 'USBOutTransferResult': false; + readonly 'UserActivation': false; + readonly 'ValidityState': false; + readonly 'VideoColorSpace': false; + readonly 'VideoDecoder': false; + readonly 'VideoEncoder': false; + readonly 'VideoFrame': false; + readonly 'VideoPlaybackQuality': false; + readonly 'viewport': false; + readonly 'Viewport': false; + readonly 'ViewTimeline': false; + readonly 'ViewTransition': false; + readonly 'ViewTransitionTypeSet': false; + readonly 'VirtualKeyboard': false; + readonly 'VirtualKeyboardGeometryChangeEvent': false; + readonly 'VisibilityStateEntry': false; + readonly 'visualViewport': false; + readonly 'VisualViewport': false; + readonly 'VTTCue': false; + readonly 'VTTRegion': false; + readonly 'WakeLock': false; + readonly 'WakeLockSentinel': false; + readonly 'WaveShaperNode': false; + readonly 'WebAssembly': false; + readonly 'WebGL2RenderingContext': false; + readonly 'WebGLActiveInfo': false; + readonly 'WebGLBuffer': false; + readonly 'WebGLContextEvent': false; + readonly 'WebGLFramebuffer': false; + readonly 'WebGLObject': false; + readonly 'WebGLProgram': false; + readonly 'WebGLQuery': false; + readonly 'WebGLRenderbuffer': false; + readonly 'WebGLRenderingContext': false; + readonly 'WebGLSampler': false; + readonly 'WebGLShader': false; + readonly 'WebGLShaderPrecisionFormat': false; + readonly 'WebGLSync': false; + readonly 'WebGLTexture': false; + readonly 'WebGLTransformFeedback': false; + readonly 'WebGLUniformLocation': false; + readonly 'WebGLVertexArrayObject': false; + readonly 'WebSocket': false; + readonly 'WebSocketError': false; + readonly 'WebSocketStream': false; + readonly 'WebTransport': false; + readonly 'WebTransportBidirectionalStream': false; + readonly 'WebTransportDatagramDuplexStream': false; + readonly 'WebTransportError': false; + readonly 'WebTransportReceiveStream': false; + readonly 'WebTransportSendStream': false; + readonly 'WGSLLanguageFeatures': false; + readonly 'WheelEvent': false; + readonly 'when': false; + readonly 'window': false; + readonly 'Window': false; + readonly 'WindowControlsOverlay': false; + readonly 'WindowControlsOverlayGeometryChangeEvent': false; + readonly 'Worker': false; + readonly 'Worklet': false; + readonly 'WorkletGlobalScope': false; + readonly 'WritableStream': false; + readonly 'WritableStreamDefaultController': false; + readonly 'WritableStreamDefaultWriter': false; + readonly 'XMLDocument': false; + readonly 'XMLHttpRequest': false; + readonly 'XMLHttpRequestEventTarget': false; + readonly 'XMLHttpRequestUpload': false; + readonly 'XMLSerializer': false; + readonly 'XPathEvaluator': false; + readonly 'XPathExpression': false; + readonly 'XPathResult': false; + readonly 'XRAnchor': false; + readonly 'XRAnchorSet': false; + readonly 'XRBoundedReferenceSpace': false; + readonly 'XRCamera': false; + readonly 'XRCPUDepthInformation': false; + readonly 'XRDepthInformation': false; + readonly 'XRDOMOverlayState': false; + readonly 'XRFrame': false; + readonly 'XRHand': false; + readonly 'XRHitTestResult': false; + readonly 'XRHitTestSource': false; + readonly 'XRInputSource': false; + readonly 'XRInputSourceArray': false; + readonly 'XRInputSourceEvent': false; + readonly 'XRInputSourcesChangeEvent': false; + readonly 'XRJointPose': false; + readonly 'XRJointSpace': false; + readonly 'XRLayer': false; + readonly 'XRLightEstimate': false; + readonly 'XRLightProbe': false; + readonly 'XRPose': false; + readonly 'XRRay': false; + readonly 'XRReferenceSpace': false; + readonly 'XRReferenceSpaceEvent': false; + readonly 'XRRenderState': false; + readonly 'XRRigidTransform': false; + readonly 'XRSession': false; + readonly 'XRSessionEvent': false; + readonly 'XRSpace': false; + readonly 'XRSystem': false; + readonly 'XRTransientInputHitTestResult': false; + readonly 'XRTransientInputHitTestSource': false; + readonly 'XRView': false; + readonly 'XRViewerPose': false; + readonly 'XRViewport': false; + readonly 'XRWebGLBinding': false; + readonly 'XRWebGLDepthInformation': false; + readonly 'XRWebGLLayer': false; + readonly 'XSLTProcessor': false; +} + +type GlobalsBuiltin = { + readonly 'AggregateError': false; + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Atomics': false; + readonly 'BigInt': false; + readonly 'BigInt64Array': false; + readonly 'BigUint64Array': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'FinalizationRegistry': false; + readonly 'Float16Array': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'globalThis': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'Iterator': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'SharedArrayBuffer': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakRef': false; + readonly 'WeakSet': false; +} + +type GlobalsChai = { + readonly 'assert': true; + readonly 'expect': true; + readonly 'should': true; +} + +type GlobalsCommonjs = { + readonly 'exports': true; + readonly 'global': false; + readonly 'module': false; + readonly 'require': false; +} + +type GlobalsCouch = { + readonly 'emit': false; + readonly 'exports': false; + readonly 'getRow': false; + readonly 'log': false; + readonly 'module': false; + readonly 'provides': false; + readonly 'require': false; + readonly 'respond': false; + readonly 'send': false; + readonly 'start': false; + readonly 'sum': false; +} + +type GlobalsDevtools = { + readonly '$': false; + readonly '$_': false; + readonly '$$': false; + readonly '$0': false; + readonly '$1': false; + readonly '$2': false; + readonly '$3': false; + readonly '$4': false; + readonly '$x': false; + readonly 'chrome': false; + readonly 'clear': false; + readonly 'copy': false; + readonly 'debug': false; + readonly 'dir': false; + readonly 'dirxml': false; + readonly 'getEventListeners': false; + readonly 'inspect': false; + readonly 'keys': false; + readonly 'monitor': false; + readonly 'monitorEvents': false; + readonly 'profile': false; + readonly 'profileEnd': false; + readonly 'queryObjects': false; + readonly 'table': false; + readonly 'undebug': false; + readonly 'unmonitor': false; + readonly 'unmonitorEvents': false; + readonly 'values': false; +} + +type GlobalsEmbertest = { + readonly 'andThen': false; + readonly 'click': false; + readonly 'currentPath': false; + readonly 'currentRouteName': false; + readonly 'currentURL': false; + readonly 'fillIn': false; + readonly 'find': false; + readonly 'findAll': false; + readonly 'findWithAssert': false; + readonly 'keyEvent': false; + readonly 'pauseTest': false; + readonly 'resumeTest': false; + readonly 'triggerEvent': false; + readonly 'visit': false; + readonly 'wait': false; +} + +type GlobalsEs2015 = { + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakSet': false; +} + +type GlobalsEs2016 = { + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakSet': false; +} + +type GlobalsEs2017 = { + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Atomics': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'SharedArrayBuffer': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakSet': false; +} + +type GlobalsEs2018 = { + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Atomics': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'SharedArrayBuffer': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakSet': false; +} + +type GlobalsEs2019 = { + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Atomics': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'SharedArrayBuffer': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakSet': false; +} + +type GlobalsEs2020 = { + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Atomics': false; + readonly 'BigInt': false; + readonly 'BigInt64Array': false; + readonly 'BigUint64Array': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'globalThis': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'SharedArrayBuffer': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakSet': false; +} + +type GlobalsEs2021 = { + readonly 'AggregateError': false; + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Atomics': false; + readonly 'BigInt': false; + readonly 'BigInt64Array': false; + readonly 'BigUint64Array': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'FinalizationRegistry': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'globalThis': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'SharedArrayBuffer': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakRef': false; + readonly 'WeakSet': false; +} + +type GlobalsEs2022 = { + readonly 'AggregateError': false; + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Atomics': false; + readonly 'BigInt': false; + readonly 'BigInt64Array': false; + readonly 'BigUint64Array': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'FinalizationRegistry': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'globalThis': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'SharedArrayBuffer': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakRef': false; + readonly 'WeakSet': false; +} + +type GlobalsEs2023 = { + readonly 'AggregateError': false; + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Atomics': false; + readonly 'BigInt': false; + readonly 'BigInt64Array': false; + readonly 'BigUint64Array': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'FinalizationRegistry': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'globalThis': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'SharedArrayBuffer': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakRef': false; + readonly 'WeakSet': false; +} + +type GlobalsEs2024 = { + readonly 'AggregateError': false; + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Atomics': false; + readonly 'BigInt': false; + readonly 'BigInt64Array': false; + readonly 'BigUint64Array': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'FinalizationRegistry': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'globalThis': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'SharedArrayBuffer': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakRef': false; + readonly 'WeakSet': false; +} + +type GlobalsEs2025 = { + readonly 'AggregateError': false; + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Atomics': false; + readonly 'BigInt': false; + readonly 'BigInt64Array': false; + readonly 'BigUint64Array': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'FinalizationRegistry': false; + readonly 'Float16Array': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'globalThis': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'Iterator': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'SharedArrayBuffer': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakRef': false; + readonly 'WeakSet': false; +} + +type GlobalsEs2026 = { + readonly 'AggregateError': false; + readonly 'Array': false; + readonly 'ArrayBuffer': false; + readonly 'Atomics': false; + readonly 'BigInt': false; + readonly 'BigInt64Array': false; + readonly 'BigUint64Array': false; + readonly 'Boolean': false; + readonly 'DataView': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'FinalizationRegistry': false; + readonly 'Float16Array': false; + readonly 'Float32Array': false; + readonly 'Float64Array': false; + readonly 'Function': false; + readonly 'globalThis': false; + readonly 'Infinity': false; + readonly 'Int16Array': false; + readonly 'Int32Array': false; + readonly 'Int8Array': false; + readonly 'Intl': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'Iterator': false; + readonly 'JSON': false; + readonly 'Map': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'Promise': false; + readonly 'Proxy': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'Reflect': false; + readonly 'RegExp': false; + readonly 'Set': false; + readonly 'SharedArrayBuffer': false; + readonly 'String': false; + readonly 'Symbol': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'Uint16Array': false; + readonly 'Uint32Array': false; + readonly 'Uint8Array': false; + readonly 'Uint8ClampedArray': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; + readonly 'WeakMap': false; + readonly 'WeakRef': false; + readonly 'WeakSet': false; +} + +type GlobalsEs3 = { + readonly 'Array': false; + readonly 'Boolean': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'Function': false; + readonly 'Infinity': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'RegExp': false; + readonly 'String': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; +} + +type GlobalsEs5 = { + readonly 'Array': false; + readonly 'Boolean': false; + readonly 'Date': false; + readonly 'decodeURI': false; + readonly 'decodeURIComponent': false; + readonly 'encodeURI': false; + readonly 'encodeURIComponent': false; + readonly 'Error': false; + readonly 'escape': false; + readonly 'eval': false; + readonly 'EvalError': false; + readonly 'Function': false; + readonly 'Infinity': false; + readonly 'isFinite': false; + readonly 'isNaN': false; + readonly 'JSON': false; + readonly 'Math': false; + readonly 'NaN': false; + readonly 'Number': false; + readonly 'Object': false; + readonly 'parseFloat': false; + readonly 'parseInt': false; + readonly 'RangeError': false; + readonly 'ReferenceError': false; + readonly 'RegExp': false; + readonly 'String': false; + readonly 'SyntaxError': false; + readonly 'TypeError': false; + readonly 'undefined': false; + readonly 'unescape': false; + readonly 'URIError': false; +} + +type GlobalsGreasemonkey = { + readonly 'cloneInto': false; + readonly 'createObjectIn': false; + readonly 'exportFunction': false; + readonly 'GM': false; + readonly 'GM_addElement': false; + readonly 'GM_addStyle': false; + readonly 'GM_addValueChangeListener': false; + readonly 'GM_deleteValue': false; + readonly 'GM_deleteValues': false; + readonly 'GM_download': false; + readonly 'GM_getResourceText': false; + readonly 'GM_getResourceURL': false; + readonly 'GM_getTab': false; + readonly 'GM_getTabs': false; + readonly 'GM_getValue': false; + readonly 'GM_getValues': false; + readonly 'GM_info': false; + readonly 'GM_listValues': false; + readonly 'GM_log': false; + readonly 'GM_notification': false; + readonly 'GM_openInTab': false; + readonly 'GM_registerMenuCommand': false; + readonly 'GM_removeValueChangeListener': false; + readonly 'GM_saveTab': false; + readonly 'GM_setClipboard': false; + readonly 'GM_setValue': false; + readonly 'GM_setValues': false; + readonly 'GM_unregisterMenuCommand': false; + readonly 'GM_xmlhttpRequest': false; + readonly 'unsafeWindow': false; +} + +type GlobalsJasmine = { + readonly 'afterAll': false; + readonly 'afterEach': false; + readonly 'beforeAll': false; + readonly 'beforeEach': false; + readonly 'describe': false; + readonly 'expect': false; + readonly 'expectAsync': false; + readonly 'fail': false; + readonly 'fdescribe': false; + readonly 'fit': false; + readonly 'it': false; + readonly 'jasmine': false; + readonly 'pending': false; + readonly 'runs': false; + readonly 'spyOn': false; + readonly 'spyOnAllFunctions': false; + readonly 'spyOnProperty': false; + readonly 'waits': false; + readonly 'waitsFor': false; + readonly 'xdescribe': false; + readonly 'xit': false; +} + +type GlobalsJest = { + readonly 'afterAll': false; + readonly 'afterEach': false; + readonly 'beforeAll': false; + readonly 'beforeEach': false; + readonly 'describe': false; + readonly 'expect': false; + readonly 'fit': false; + readonly 'it': false; + readonly 'jest': false; + readonly 'test': false; + readonly 'xdescribe': false; + readonly 'xit': false; + readonly 'xtest': false; +} + +type GlobalsJquery = { + readonly '$': false; + readonly 'jQuery': false; +} + +type GlobalsMeteor = { + readonly '$': false; + readonly 'Accounts': false; + readonly 'AccountsClient': false; + readonly 'AccountsCommon': false; + readonly 'AccountsServer': false; + readonly 'App': false; + readonly 'Assets': false; + readonly 'Blaze': false; + readonly 'check': false; + readonly 'Cordova': false; + readonly 'DDP': false; + readonly 'DDPRateLimiter': false; + readonly 'DDPServer': false; + readonly 'Deps': false; + readonly 'EJSON': false; + readonly 'Email': false; + readonly 'HTTP': false; + readonly 'Log': false; + readonly 'Match': false; + readonly 'Meteor': false; + readonly 'Mongo': false; + readonly 'MongoInternals': false; + readonly 'Npm': false; + readonly 'Package': false; + readonly 'Plugin': false; + readonly 'process': false; + readonly 'Random': false; + readonly 'ReactiveDict': false; + readonly 'ReactiveVar': false; + readonly 'Router': false; + readonly 'ServiceConfiguration': false; + readonly 'Session': false; + readonly 'share': false; + readonly 'Spacebars': false; + readonly 'Template': false; + readonly 'Tinytest': false; + readonly 'Tracker': false; + readonly 'UI': false; + readonly 'Utils': false; + readonly 'WebApp': false; + readonly 'WebAppInternals': false; +} + +type GlobalsMocha = { + readonly 'after': false; + readonly 'afterEach': false; + readonly 'before': false; + readonly 'beforeEach': false; + readonly 'context': false; + readonly 'describe': false; + readonly 'it': false; + readonly 'mocha': false; + readonly 'run': false; + readonly 'setup': false; + readonly 'specify': false; + readonly 'suite': false; + readonly 'suiteSetup': false; + readonly 'suiteTeardown': false; + readonly 'teardown': false; + readonly 'test': false; + readonly 'xcontext': false; + readonly 'xdescribe': false; + readonly 'xit': false; + readonly 'xspecify': false; +} + +type GlobalsMongo = { + readonly '_isWindows': false; + readonly '_rand': false; + readonly 'BulkWriteResult': false; + readonly 'cat': false; + readonly 'cd': false; + readonly 'connect': false; + readonly 'db': false; + readonly 'getHostName': false; + readonly 'getMemInfo': false; + readonly 'hostname': false; + readonly 'ISODate': false; + readonly 'listFiles': false; + readonly 'load': false; + readonly 'ls': false; + readonly 'md5sumFile': false; + readonly 'mkdir': false; + readonly 'Mongo': false; + readonly 'NumberInt': false; + readonly 'NumberLong': false; + readonly 'ObjectId': false; + readonly 'PlanCache': false; + readonly 'print': false; + readonly 'printjson': false; + readonly 'pwd': false; + readonly 'quit': false; + readonly 'removeFile': false; + readonly 'rs': false; + readonly 'sh': false; + readonly 'UUID': false; + readonly 'version': false; + readonly 'WriteResult': false; +} + +type GlobalsNashorn = { + readonly '__DIR__': false; + readonly '__FILE__': false; + readonly '__LINE__': false; + readonly 'com': false; + readonly 'edu': false; + readonly 'exit': false; + readonly 'java': false; + readonly 'Java': false; + readonly 'javafx': false; + readonly 'JavaImporter': false; + readonly 'javax': false; + readonly 'JSAdapter': false; + readonly 'load': false; + readonly 'loadWithNewGlobal': false; + readonly 'org': false; + readonly 'Packages': false; + readonly 'print': false; + readonly 'quit': false; +} + +type GlobalsNode = { + readonly '__dirname': false; + readonly '__filename': false; + readonly 'AbortController': false; + readonly 'AbortSignal': false; + readonly 'AsyncDisposableStack': false; + readonly 'atob': false; + readonly 'Blob': false; + readonly 'BroadcastChannel': false; + readonly 'btoa': false; + readonly 'Buffer': false; + readonly 'ByteLengthQueuingStrategy': false; + readonly 'clearImmediate': false; + readonly 'clearInterval': false; + readonly 'clearTimeout': false; + readonly 'CloseEvent': false; + readonly 'CompressionStream': false; + readonly 'console': false; + readonly 'CountQueuingStrategy': false; + readonly 'crypto': false; + readonly 'Crypto': false; + readonly 'CryptoKey': false; + readonly 'CustomEvent': false; + readonly 'DecompressionStream': false; + readonly 'DisposableStack': false; + readonly 'DOMException': false; + readonly 'ErrorEvent': false; + readonly 'Event': false; + readonly 'EventTarget': false; + readonly 'exports': true; + readonly 'fetch': false; + readonly 'File': false; + readonly 'FormData': false; + readonly 'global': false; + readonly 'Headers': false; + readonly 'localStorage': false; + readonly 'MessageChannel': false; + readonly 'MessageEvent': false; + readonly 'MessagePort': false; + readonly 'module': false; + readonly 'navigator': false; + readonly 'Navigator': false; + readonly 'performance': false; + readonly 'Performance': false; + readonly 'PerformanceEntry': false; + readonly 'PerformanceMark': false; + readonly 'PerformanceMeasure': false; + readonly 'PerformanceObserver': false; + readonly 'PerformanceObserverEntryList': false; + readonly 'PerformanceResourceTiming': false; + readonly 'process': false; + readonly 'queueMicrotask': false; + readonly 'ReadableByteStreamController': false; + readonly 'ReadableStream': false; + readonly 'ReadableStreamBYOBReader': false; + readonly 'ReadableStreamBYOBRequest': false; + readonly 'ReadableStreamDefaultController': false; + readonly 'ReadableStreamDefaultReader': false; + readonly 'Request': false; + readonly 'require': false; + readonly 'Response': false; + readonly 'sessionStorage': false; + readonly 'setImmediate': false; + readonly 'setInterval': false; + readonly 'setTimeout': false; + readonly 'Storage': false; + readonly 'structuredClone': false; + readonly 'SubtleCrypto': false; + readonly 'SuppressedError': false; + readonly 'TextDecoder': false; + readonly 'TextDecoderStream': false; + readonly 'TextEncoder': false; + readonly 'TextEncoderStream': false; + readonly 'TransformStream': false; + readonly 'TransformStreamDefaultController': false; + readonly 'URL': false; + readonly 'URLPattern': false; + readonly 'URLSearchParams': false; + readonly 'WebAssembly': false; + readonly 'WebSocket': false; + readonly 'WritableStream': false; + readonly 'WritableStreamDefaultController': false; + readonly 'WritableStreamDefaultWriter': false; +} + +type GlobalsNodeBuiltin = { + readonly 'AbortController': false; + readonly 'AbortSignal': false; + readonly 'AsyncDisposableStack': false; + readonly 'atob': false; + readonly 'Blob': false; + readonly 'BroadcastChannel': false; + readonly 'btoa': false; + readonly 'Buffer': false; + readonly 'ByteLengthQueuingStrategy': false; + readonly 'clearImmediate': false; + readonly 'clearInterval': false; + readonly 'clearTimeout': false; + readonly 'CloseEvent': false; + readonly 'CompressionStream': false; + readonly 'console': false; + readonly 'CountQueuingStrategy': false; + readonly 'crypto': false; + readonly 'Crypto': false; + readonly 'CryptoKey': false; + readonly 'CustomEvent': false; + readonly 'DecompressionStream': false; + readonly 'DisposableStack': false; + readonly 'DOMException': false; + readonly 'ErrorEvent': false; + readonly 'Event': false; + readonly 'EventTarget': false; + readonly 'fetch': false; + readonly 'File': false; + readonly 'FormData': false; + readonly 'global': false; + readonly 'Headers': false; + readonly 'localStorage': false; + readonly 'MessageChannel': false; + readonly 'MessageEvent': false; + readonly 'MessagePort': false; + readonly 'navigator': false; + readonly 'Navigator': false; + readonly 'performance': false; + readonly 'Performance': false; + readonly 'PerformanceEntry': false; + readonly 'PerformanceMark': false; + readonly 'PerformanceMeasure': false; + readonly 'PerformanceObserver': false; + readonly 'PerformanceObserverEntryList': false; + readonly 'PerformanceResourceTiming': false; + readonly 'process': false; + readonly 'queueMicrotask': false; + readonly 'ReadableByteStreamController': false; + readonly 'ReadableStream': false; + readonly 'ReadableStreamBYOBReader': false; + readonly 'ReadableStreamBYOBRequest': false; + readonly 'ReadableStreamDefaultController': false; + readonly 'ReadableStreamDefaultReader': false; + readonly 'Request': false; + readonly 'Response': false; + readonly 'sessionStorage': false; + readonly 'setImmediate': false; + readonly 'setInterval': false; + readonly 'setTimeout': false; + readonly 'Storage': false; + readonly 'structuredClone': false; + readonly 'SubtleCrypto': false; + readonly 'SuppressedError': false; + readonly 'TextDecoder': false; + readonly 'TextDecoderStream': false; + readonly 'TextEncoder': false; + readonly 'TextEncoderStream': false; + readonly 'TransformStream': false; + readonly 'TransformStreamDefaultController': false; + readonly 'URL': false; + readonly 'URLPattern': false; + readonly 'URLSearchParams': false; + readonly 'WebAssembly': false; + readonly 'WebSocket': false; + readonly 'WritableStream': false; + readonly 'WritableStreamDefaultController': false; + readonly 'WritableStreamDefaultWriter': false; +} + +type GlobalsPhantomjs = { + readonly 'console': true; + readonly 'exports': true; + readonly 'phantom': true; + readonly 'require': true; + readonly 'WebPage': true; +} + +type GlobalsPrototypejs = { + readonly '$': false; + readonly '$$': false; + readonly '$A': false; + readonly '$break': false; + readonly '$continue': false; + readonly '$F': false; + readonly '$H': false; + readonly '$R': false; + readonly '$w': false; + readonly 'Abstract': false; + readonly 'Ajax': false; + readonly 'Autocompleter': false; + readonly 'Builder': false; + readonly 'Class': false; + readonly 'Control': false; + readonly 'Draggable': false; + readonly 'Draggables': false; + readonly 'Droppables': false; + readonly 'Effect': false; + readonly 'Element': false; + readonly 'Enumerable': false; + readonly 'Event': false; + readonly 'Field': false; + readonly 'Form': false; + readonly 'Hash': false; + readonly 'Insertion': false; + readonly 'ObjectRange': false; + readonly 'PeriodicalExecuter': false; + readonly 'Position': false; + readonly 'Prototype': false; + readonly 'Scriptaculous': false; + readonly 'Selector': false; + readonly 'Sortable': false; + readonly 'SortableObserver': false; + readonly 'Sound': false; + readonly 'Template': false; + readonly 'Toggle': false; + readonly 'Try': false; +} + +type GlobalsProtractor = { + readonly '$': false; + readonly '$$': false; + readonly 'browser': false; + readonly 'by': false; + readonly 'By': false; + readonly 'DartObject': false; + readonly 'element': false; + readonly 'protractor': false; +} + +type GlobalsQunit = { + readonly 'asyncTest': false; + readonly 'deepEqual': false; + readonly 'equal': false; + readonly 'expect': false; + readonly 'module': false; + readonly 'notDeepEqual': false; + readonly 'notEqual': false; + readonly 'notOk': false; + readonly 'notPropEqual': false; + readonly 'notStrictEqual': false; + readonly 'ok': false; + readonly 'propEqual': false; + readonly 'QUnit': false; + readonly 'raises': false; + readonly 'start': false; + readonly 'stop': false; + readonly 'strictEqual': false; + readonly 'test': false; + readonly 'throws': false; +} + +type GlobalsRhino = { + readonly 'defineClass': false; + readonly 'deserialize': false; + readonly 'gc': false; + readonly 'help': false; + readonly 'importClass': false; + readonly 'importPackage': false; + readonly 'java': false; + readonly 'load': false; + readonly 'loadClass': false; + readonly 'Packages': false; + readonly 'print': false; + readonly 'quit': false; + readonly 'readFile': false; + readonly 'readUrl': false; + readonly 'runCommand': false; + readonly 'seal': false; + readonly 'serialize': false; + readonly 'spawn': false; + readonly 'sync': false; + readonly 'toint32': false; + readonly 'version': false; +} + +type GlobalsServiceworker = { + readonly 'AbortController': false; + readonly 'AbortPaymentEvent': false; + readonly 'AbortSignal': false; + readonly 'addEventListener': false; + readonly 'ai': false; + readonly 'AI': false; + readonly 'AICreateMonitor': false; + readonly 'AsyncDisposableStack': false; + readonly 'atob': false; + readonly 'BackgroundFetchEvent': false; + readonly 'BackgroundFetchManager': false; + readonly 'BackgroundFetchRecord': false; + readonly 'BackgroundFetchRegistration': false; + readonly 'BackgroundFetchUpdateUIEvent': false; + readonly 'BarcodeDetector': false; + readonly 'Blob': false; + readonly 'BroadcastChannel': false; + readonly 'btoa': false; + readonly 'ByteLengthQueuingStrategy': false; + readonly 'Cache': false; + readonly 'caches': false; + readonly 'CacheStorage': false; + readonly 'CanMakePaymentEvent': false; + readonly 'CanvasGradient': false; + readonly 'CanvasPattern': false; + readonly 'clearInterval': false; + readonly 'clearTimeout': false; + readonly 'Client': false; + readonly 'clients': false; + readonly 'Clients': false; + readonly 'CloseEvent': false; + readonly 'CompressionStream': false; + readonly 'console': false; + readonly 'cookieStore': false; + readonly 'CookieStore': false; + readonly 'CookieStoreManager': false; + readonly 'CountQueuingStrategy': false; + readonly 'createImageBitmap': false; + readonly 'CreateMonitor': false; + readonly 'CropTarget': false; + readonly 'crossOriginIsolated': false; + readonly 'crypto': false; + readonly 'Crypto': false; + readonly 'CryptoKey': false; + readonly 'CSSSkewX': false; + readonly 'CSSSkewY': false; + readonly 'CustomEvent': false; + readonly 'DecompressionStream': false; + readonly 'dispatchEvent': false; + readonly 'DisposableStack': false; + readonly 'DOMException': false; + readonly 'DOMMatrix': false; + readonly 'DOMMatrixReadOnly': false; + readonly 'DOMPoint': false; + readonly 'DOMPointReadOnly': false; + readonly 'DOMQuad': false; + readonly 'DOMRect': false; + readonly 'DOMRectReadOnly': false; + readonly 'DOMStringList': false; + readonly 'ErrorEvent': false; + readonly 'Event': false; + readonly 'EventSource': false; + readonly 'EventTarget': false; + readonly 'ExtendableCookieChangeEvent': false; + readonly 'ExtendableEvent': false; + readonly 'ExtendableMessageEvent': false; + readonly 'fetch': false; + readonly 'FetchEvent': false; + readonly 'File': false; + readonly 'FileList': false; + readonly 'FileReader': false; + readonly 'FileSystemDirectoryHandle': false; + readonly 'FileSystemFileHandle': false; + readonly 'FileSystemHandle': false; + readonly 'FileSystemWritableFileStream': false; + readonly 'FontFace': false; + readonly 'fonts': false; + readonly 'FormData': false; + readonly 'GPU': false; + readonly 'GPUAdapter': false; + readonly 'GPUAdapterInfo': false; + readonly 'GPUBindGroup': false; + readonly 'GPUBindGroupLayout': false; + readonly 'GPUBuffer': false; + readonly 'GPUBufferUsage': false; + readonly 'GPUCanvasContext': false; + readonly 'GPUColorWrite': false; + readonly 'GPUCommandBuffer': false; + readonly 'GPUCommandEncoder': false; + readonly 'GPUCompilationInfo': false; + readonly 'GPUCompilationMessage': false; + readonly 'GPUComputePassEncoder': false; + readonly 'GPUComputePipeline': false; + readonly 'GPUDevice': false; + readonly 'GPUDeviceLostInfo': false; + readonly 'GPUError': false; + readonly 'GPUExternalTexture': false; + readonly 'GPUInternalError': false; + readonly 'GPUMapMode': false; + readonly 'GPUOutOfMemoryError': false; + readonly 'GPUPipelineError': false; + readonly 'GPUPipelineLayout': false; + readonly 'GPUQuerySet': false; + readonly 'GPUQueue': false; + readonly 'GPURenderBundle': false; + readonly 'GPURenderBundleEncoder': false; + readonly 'GPURenderPassEncoder': false; + readonly 'GPURenderPipeline': false; + readonly 'GPUSampler': false; + readonly 'GPUShaderModule': false; + readonly 'GPUShaderStage': false; + readonly 'GPUSupportedFeatures': false; + readonly 'GPUSupportedLimits': false; + readonly 'GPUTexture': false; + readonly 'GPUTextureUsage': false; + readonly 'GPUTextureView': false; + readonly 'GPUUncapturedErrorEvent': false; + readonly 'GPUValidationError': false; + readonly 'Headers': false; + readonly 'IDBCursor': false; + readonly 'IDBCursorWithValue': false; + readonly 'IDBDatabase': false; + readonly 'IDBFactory': false; + readonly 'IDBIndex': false; + readonly 'IDBKeyRange': false; + readonly 'IDBObjectStore': false; + readonly 'IDBOpenDBRequest': false; + readonly 'IDBRecord': false; + readonly 'IDBRequest': false; + readonly 'IDBTransaction': false; + readonly 'IDBVersionChangeEvent': false; + readonly 'ImageBitmap': false; + readonly 'ImageBitmapRenderingContext': false; + readonly 'ImageData': false; + readonly 'importScripts': false; + readonly 'indexedDB': false; + readonly 'InstallEvent': false; + readonly 'isSecureContext': false; + readonly 'LanguageDetector': false; + readonly 'location': false; + readonly 'Lock': false; + readonly 'LockManager': false; + readonly 'MediaCapabilities': false; + readonly 'MessageChannel': false; + readonly 'MessageEvent': false; + readonly 'MessagePort': false; + readonly 'NavigationPreloadManager': false; + readonly 'navigator': false; + readonly 'NavigatorUAData': false; + readonly 'NetworkInformation': false; + readonly 'Notification': false; + readonly 'NotificationEvent': false; + readonly 'Observable': false; + readonly 'OffscreenCanvas': false; + readonly 'OffscreenCanvasRenderingContext2D': false; + readonly 'onabortpayment': true; + readonly 'onactivate': true; + readonly 'onbackgroundfetchabort': true; + readonly 'onbackgroundfetchclick': true; + readonly 'onbackgroundfetchfail': true; + readonly 'onbackgroundfetchsuccess': true; + readonly 'oncanmakepayment': true; + readonly 'oncookiechange': true; + readonly 'onerror': true; + readonly 'onfetch': true; + readonly 'oninstall': true; + readonly 'onlanguagechange': true; + readonly 'onmessage': true; + readonly 'onmessageerror': true; + readonly 'onnotificationclick': true; + readonly 'onnotificationclose': true; + readonly 'onpaymentrequest': true; + readonly 'onperiodicsync': true; + readonly 'onpush': true; + readonly 'onpushsubscriptionchange': true; + readonly 'onrejectionhandled': true; + readonly 'onsync': true; + readonly 'onunhandledrejection': true; + readonly 'origin': false; + readonly 'Path2D': false; + readonly 'PaymentRequestEvent': false; + readonly 'performance': false; + readonly 'Performance': false; + readonly 'PerformanceEntry': false; + readonly 'PerformanceMark': false; + readonly 'PerformanceMeasure': false; + readonly 'PerformanceObserver': false; + readonly 'PerformanceObserverEntryList': false; + readonly 'PerformanceResourceTiming': false; + readonly 'PerformanceServerTiming': false; + readonly 'PeriodicSyncEvent': false; + readonly 'PeriodicSyncManager': false; + readonly 'Permissions': false; + readonly 'PermissionStatus': false; + readonly 'PromiseRejectionEvent': false; + readonly 'PushEvent': false; + readonly 'PushManager': false; + readonly 'PushMessageData': false; + readonly 'PushSubscription': false; + readonly 'PushSubscriptionChangeEvent': false; + readonly 'PushSubscriptionOptions': false; + readonly 'queueMicrotask': false; + readonly 'QuotaExceededError': false; + readonly 'ReadableByteStreamController': false; + readonly 'ReadableStream': false; + readonly 'ReadableStreamBYOBReader': false; + readonly 'ReadableStreamBYOBRequest': false; + readonly 'ReadableStreamDefaultController': false; + readonly 'ReadableStreamDefaultReader': false; + readonly 'registration': false; + readonly 'removeEventListener': false; + readonly 'ReportBody': false; + readonly 'reportError': false; + readonly 'ReportingObserver': false; + readonly 'Request': false; + readonly 'Response': false; + readonly 'RestrictionTarget': false; + readonly 'scheduler': false; + readonly 'Scheduler': false; + readonly 'SecurityPolicyViolationEvent': false; + readonly 'self': false; + readonly 'serviceWorker': false; + readonly 'ServiceWorker': false; + readonly 'ServiceWorkerGlobalScope': false; + readonly 'ServiceWorkerRegistration': false; + readonly 'setInterval': false; + readonly 'setTimeout': false; + readonly 'skipWaiting': false; + readonly 'StorageBucket': false; + readonly 'StorageBucketManager': false; + readonly 'StorageManager': false; + readonly 'structuredClone': false; + readonly 'Subscriber': false; + readonly 'SubtleCrypto': false; + readonly 'SuppressedError': false; + readonly 'SyncEvent': false; + readonly 'SyncManager': false; + readonly 'TaskController': false; + readonly 'TaskPriorityChangeEvent': false; + readonly 'TaskSignal': false; + readonly 'TextDecoder': false; + readonly 'TextDecoderStream': false; + readonly 'TextEncoder': false; + readonly 'TextEncoderStream': false; + readonly 'TextMetrics': false; + readonly 'TransformStream': false; + readonly 'TransformStreamDefaultController': false; + readonly 'TrustedHTML': false; + readonly 'TrustedScript': false; + readonly 'TrustedScriptURL': false; + readonly 'TrustedTypePolicy': false; + readonly 'TrustedTypePolicyFactory': false; + readonly 'trustedTypes': false; + readonly 'URL': false; + readonly 'URLPattern': false; + readonly 'URLSearchParams': false; + readonly 'UserActivation': false; + readonly 'WebAssembly': false; + readonly 'WebGL2RenderingContext': false; + readonly 'WebGLActiveInfo': false; + readonly 'WebGLBuffer': false; + readonly 'WebGLContextEvent': false; + readonly 'WebGLFramebuffer': false; + readonly 'WebGLObject': false; + readonly 'WebGLProgram': false; + readonly 'WebGLQuery': false; + readonly 'WebGLRenderbuffer': false; + readonly 'WebGLRenderingContext': false; + readonly 'WebGLSampler': false; + readonly 'WebGLShader': false; + readonly 'WebGLShaderPrecisionFormat': false; + readonly 'WebGLSync': false; + readonly 'WebGLTexture': false; + readonly 'WebGLTransformFeedback': false; + readonly 'WebGLUniformLocation': false; + readonly 'WebGLVertexArrayObject': false; + readonly 'WebSocket': false; + readonly 'WebSocketError': false; + readonly 'WebSocketStream': false; + readonly 'WebTransport': false; + readonly 'WebTransportBidirectionalStream': false; + readonly 'WebTransportDatagramDuplexStream': false; + readonly 'WebTransportError': false; + readonly 'WGSLLanguageFeatures': false; + readonly 'when': false; + readonly 'WindowClient': false; + readonly 'WorkerGlobalScope': false; + readonly 'WorkerLocation': false; + readonly 'WorkerNavigator': false; + readonly 'WritableStream': false; + readonly 'WritableStreamDefaultController': false; + readonly 'WritableStreamDefaultWriter': false; +} + +type GlobalsSharednodebrowser = { + readonly 'AbortController': false; + readonly 'AbortSignal': false; + readonly 'AsyncDisposableStack': false; + readonly 'atob': false; + readonly 'Blob': false; + readonly 'BroadcastChannel': false; + readonly 'btoa': false; + readonly 'ByteLengthQueuingStrategy': false; + readonly 'clearInterval': false; + readonly 'clearTimeout': false; + readonly 'CloseEvent': false; + readonly 'CompressionStream': false; + readonly 'console': false; + readonly 'CountQueuingStrategy': false; + readonly 'crypto': false; + readonly 'Crypto': false; + readonly 'CryptoKey': false; + readonly 'CustomEvent': false; + readonly 'DecompressionStream': false; + readonly 'DisposableStack': false; + readonly 'DOMException': false; + readonly 'ErrorEvent': false; + readonly 'Event': false; + readonly 'EventTarget': false; + readonly 'fetch': false; + readonly 'File': false; + readonly 'FormData': false; + readonly 'Headers': false; + readonly 'localStorage': false; + readonly 'MessageChannel': false; + readonly 'MessageEvent': false; + readonly 'MessagePort': false; + readonly 'navigator': false; + readonly 'Navigator': false; + readonly 'performance': false; + readonly 'Performance': false; + readonly 'PerformanceEntry': false; + readonly 'PerformanceMark': false; + readonly 'PerformanceMeasure': false; + readonly 'PerformanceObserver': false; + readonly 'PerformanceObserverEntryList': false; + readonly 'PerformanceResourceTiming': false; + readonly 'queueMicrotask': false; + readonly 'ReadableByteStreamController': false; + readonly 'ReadableStream': false; + readonly 'ReadableStreamBYOBReader': false; + readonly 'ReadableStreamBYOBRequest': false; + readonly 'ReadableStreamDefaultController': false; + readonly 'ReadableStreamDefaultReader': false; + readonly 'Request': false; + readonly 'Response': false; + readonly 'sessionStorage': false; + readonly 'setInterval': false; + readonly 'setTimeout': false; + readonly 'Storage': false; + readonly 'structuredClone': false; + readonly 'SubtleCrypto': false; + readonly 'SuppressedError': false; + readonly 'TextDecoder': false; + readonly 'TextDecoderStream': false; + readonly 'TextEncoder': false; + readonly 'TextEncoderStream': false; + readonly 'TransformStream': false; + readonly 'TransformStreamDefaultController': false; + readonly 'URL': false; + readonly 'URLPattern': false; + readonly 'URLSearchParams': false; + readonly 'WebAssembly': false; + readonly 'WebSocket': false; + readonly 'WritableStream': false; + readonly 'WritableStreamDefaultController': false; + readonly 'WritableStreamDefaultWriter': false; +} + +type GlobalsShelljs = { + readonly 'cat': false; + readonly 'cd': false; + readonly 'chmod': false; + readonly 'cmd': false; + readonly 'config': false; + readonly 'cp': false; + readonly 'dirs': false; + readonly 'echo': false; + readonly 'env': false; + readonly 'error': false; + readonly 'errorCode': false; + readonly 'exec': false; + readonly 'exit': false; + readonly 'find': false; + readonly 'grep': false; + readonly 'head': false; + readonly 'ln': false; + readonly 'ls': false; + readonly 'mkdir': false; + readonly 'mv': false; + readonly 'popd': false; + readonly 'pushd': false; + readonly 'pwd': false; + readonly 'rm': false; + readonly 'sed': false; + readonly 'set': false; + readonly 'ShellString': false; + readonly 'sort': false; + readonly 'tail': false; + readonly 'tempdir': false; + readonly 'test': false; + readonly 'touch': false; + readonly 'uniq': false; + readonly 'which': false; +} + +type GlobalsSvelte = { + readonly '$bindable': false; + readonly '$derived': false; + readonly '$effect': false; + readonly '$host': false; + readonly '$inspect': false; + readonly '$props': false; + readonly '$state': false; +} + +type GlobalsVitest = { + readonly 'afterAll': false; + readonly 'afterEach': false; + readonly 'assert': false; + readonly 'assertType': false; + readonly 'beforeAll': false; + readonly 'beforeEach': false; + readonly 'chai': false; + readonly 'describe': false; + readonly 'expect': false; + readonly 'expectTypeOf': false; + readonly 'it': false; + readonly 'onTestFailed': false; + readonly 'onTestFinished': false; + readonly 'suite': false; + readonly 'test': false; + readonly 'vi': false; + readonly 'vitest': false; +} + +type GlobalsVue = { + readonly 'defineEmits': false; + readonly 'defineExpose': false; + readonly 'defineModel': false; + readonly 'defineOptions': false; + readonly 'defineProps': false; + readonly 'defineSlots': false; + readonly 'withDefaults': false; +} + +type GlobalsWebextensions = { + readonly 'browser': false; + readonly 'chrome': false; + readonly 'opr': false; +} + +type GlobalsWorker = { + readonly 'AbortController': false; + readonly 'AbortSignal': false; + readonly 'addEventListener': false; + readonly 'ai': false; + readonly 'AI': false; + readonly 'AICreateMonitor': false; + readonly 'AsyncDisposableStack': false; + readonly 'atob': false; + readonly 'AudioData': false; + readonly 'AudioDecoder': false; + readonly 'AudioEncoder': false; + readonly 'BackgroundFetchManager': false; + readonly 'BackgroundFetchRecord': false; + readonly 'BackgroundFetchRegistration': false; + readonly 'BarcodeDetector': false; + readonly 'Blob': false; + readonly 'BroadcastChannel': false; + readonly 'btoa': false; + readonly 'ByteLengthQueuingStrategy': false; + readonly 'Cache': false; + readonly 'caches': false; + readonly 'CacheStorage': false; + readonly 'cancelAnimationFrame': false; + readonly 'CanvasGradient': false; + readonly 'CanvasPattern': false; + readonly 'clearInterval': false; + readonly 'clearTimeout': false; + readonly 'close': false; + readonly 'CloseEvent': false; + readonly 'CompressionStream': false; + readonly 'console': false; + readonly 'CountQueuingStrategy': false; + readonly 'createImageBitmap': false; + readonly 'CreateMonitor': false; + readonly 'CropTarget': false; + readonly 'crossOriginIsolated': false; + readonly 'crypto': false; + readonly 'Crypto': false; + readonly 'CryptoKey': false; + readonly 'CSSSkewX': false; + readonly 'CSSSkewY': false; + readonly 'CustomEvent': false; + readonly 'DecompressionStream': false; + readonly 'DedicatedWorkerGlobalScope': false; + readonly 'dispatchEvent': false; + readonly 'DisposableStack': false; + readonly 'DOMException': false; + readonly 'DOMMatrix': false; + readonly 'DOMMatrixReadOnly': false; + readonly 'DOMPoint': false; + readonly 'DOMPointReadOnly': false; + readonly 'DOMQuad': false; + readonly 'DOMRect': false; + readonly 'DOMRectReadOnly': false; + readonly 'DOMStringList': false; + readonly 'EncodedAudioChunk': false; + readonly 'EncodedVideoChunk': false; + readonly 'ErrorEvent': false; + readonly 'Event': false; + readonly 'EventSource': false; + readonly 'EventTarget': false; + readonly 'fetch': false; + readonly 'File': false; + readonly 'FileList': false; + readonly 'FileReader': false; + readonly 'FileReaderSync': false; + readonly 'FileSystemDirectoryHandle': false; + readonly 'FileSystemFileHandle': false; + readonly 'FileSystemHandle': false; + readonly 'FileSystemObserver': false; + readonly 'FileSystemSyncAccessHandle': false; + readonly 'FileSystemWritableFileStream': false; + readonly 'FontFace': false; + readonly 'fonts': false; + readonly 'FormData': false; + readonly 'GPU': false; + readonly 'GPUAdapter': false; + readonly 'GPUAdapterInfo': false; + readonly 'GPUBindGroup': false; + readonly 'GPUBindGroupLayout': false; + readonly 'GPUBuffer': false; + readonly 'GPUBufferUsage': false; + readonly 'GPUCanvasContext': false; + readonly 'GPUColorWrite': false; + readonly 'GPUCommandBuffer': false; + readonly 'GPUCommandEncoder': false; + readonly 'GPUCompilationInfo': false; + readonly 'GPUCompilationMessage': false; + readonly 'GPUComputePassEncoder': false; + readonly 'GPUComputePipeline': false; + readonly 'GPUDevice': false; + readonly 'GPUDeviceLostInfo': false; + readonly 'GPUError': false; + readonly 'GPUExternalTexture': false; + readonly 'GPUInternalError': false; + readonly 'GPUMapMode': false; + readonly 'GPUOutOfMemoryError': false; + readonly 'GPUPipelineError': false; + readonly 'GPUPipelineLayout': false; + readonly 'GPUQuerySet': false; + readonly 'GPUQueue': false; + readonly 'GPURenderBundle': false; + readonly 'GPURenderBundleEncoder': false; + readonly 'GPURenderPassEncoder': false; + readonly 'GPURenderPipeline': false; + readonly 'GPUSampler': false; + readonly 'GPUShaderModule': false; + readonly 'GPUShaderStage': false; + readonly 'GPUSupportedFeatures': false; + readonly 'GPUSupportedLimits': false; + readonly 'GPUTexture': false; + readonly 'GPUTextureUsage': false; + readonly 'GPUTextureView': false; + readonly 'GPUUncapturedErrorEvent': false; + readonly 'GPUValidationError': false; + readonly 'Headers': false; + readonly 'HID': false; + readonly 'HIDConnectionEvent': false; + readonly 'HIDDevice': false; + readonly 'HIDInputReportEvent': false; + readonly 'IDBCursor': false; + readonly 'IDBCursorWithValue': false; + readonly 'IDBDatabase': false; + readonly 'IDBFactory': false; + readonly 'IDBIndex': false; + readonly 'IDBKeyRange': false; + readonly 'IDBObjectStore': false; + readonly 'IDBOpenDBRequest': false; + readonly 'IDBRecord': false; + readonly 'IDBRequest': false; + readonly 'IDBTransaction': false; + readonly 'IDBVersionChangeEvent': false; + readonly 'IdleDetector': false; + readonly 'ImageBitmap': false; + readonly 'ImageBitmapRenderingContext': false; + readonly 'ImageData': false; + readonly 'ImageDecoder': false; + readonly 'ImageTrack': false; + readonly 'ImageTrackList': false; + readonly 'importScripts': false; + readonly 'indexedDB': false; + readonly 'isSecureContext': false; + readonly 'LanguageDetector': false; + readonly 'location': false; + readonly 'Lock': false; + readonly 'LockManager': false; + readonly 'MediaCapabilities': false; + readonly 'MediaSource': false; + readonly 'MediaSourceHandle': false; + readonly 'MessageChannel': false; + readonly 'MessageEvent': false; + readonly 'MessagePort': false; + readonly 'name': false; + readonly 'NavigationPreloadManager': false; + readonly 'navigator': false; + readonly 'NavigatorUAData': false; + readonly 'NetworkInformation': false; + readonly 'Notification': false; + readonly 'Observable': false; + readonly 'OffscreenCanvas': false; + readonly 'OffscreenCanvasRenderingContext2D': false; + readonly 'onerror': true; + readonly 'onlanguagechange': true; + readonly 'onmessage': true; + readonly 'onmessageerror': true; + readonly 'onrejectionhandled': true; + readonly 'onrtctransform': true; + readonly 'onunhandledrejection': true; + readonly 'origin': false; + readonly 'Path2D': false; + readonly 'performance': false; + readonly 'Performance': false; + readonly 'PerformanceEntry': false; + readonly 'PerformanceMark': false; + readonly 'PerformanceMeasure': false; + readonly 'PerformanceObserver': false; + readonly 'PerformanceObserverEntryList': false; + readonly 'PerformanceResourceTiming': false; + readonly 'PerformanceServerTiming': false; + readonly 'PeriodicSyncManager': false; + readonly 'Permissions': false; + readonly 'PermissionStatus': false; + readonly 'PERSISTENT': false; + readonly 'postMessage': false; + readonly 'PressureObserver': false; + readonly 'PressureRecord': false; + readonly 'ProgressEvent': false; + readonly 'PromiseRejectionEvent': false; + readonly 'PushManager': false; + readonly 'PushSubscription': false; + readonly 'PushSubscriptionOptions': false; + readonly 'queueMicrotask': false; + readonly 'QuotaExceededError': false; + readonly 'ReadableByteStreamController': false; + readonly 'ReadableStream': false; + readonly 'ReadableStreamBYOBReader': false; + readonly 'ReadableStreamBYOBRequest': false; + readonly 'ReadableStreamDefaultController': false; + readonly 'ReadableStreamDefaultReader': false; + readonly 'removeEventListener': false; + readonly 'ReportBody': false; + readonly 'reportError': false; + readonly 'ReportingObserver': false; + readonly 'Request': false; + readonly 'requestAnimationFrame': false; + readonly 'Response': false; + readonly 'RestrictionTarget': false; + readonly 'RTCDataChannel': false; + readonly 'RTCEncodedAudioFrame': false; + readonly 'RTCEncodedVideoFrame': false; + readonly 'RTCRtpScriptTransformer': false; + readonly 'RTCTransformEvent': false; + readonly 'scheduler': false; + readonly 'Scheduler': false; + readonly 'SecurityPolicyViolationEvent': false; + readonly 'self': false; + readonly 'Serial': false; + readonly 'SerialPort': false; + readonly 'ServiceWorkerRegistration': false; + readonly 'setInterval': false; + readonly 'setTimeout': false; + readonly 'SourceBuffer': false; + readonly 'SourceBufferList': false; + readonly 'StorageBucket': false; + readonly 'StorageBucketManager': false; + readonly 'StorageManager': false; + readonly 'structuredClone': false; + readonly 'Subscriber': false; + readonly 'SubtleCrypto': false; + readonly 'SuppressedError': false; + readonly 'SyncManager': false; + readonly 'TaskController': false; + readonly 'TaskPriorityChangeEvent': false; + readonly 'TaskSignal': false; + readonly 'TEMPORARY': false; + readonly 'TextDecoder': false; + readonly 'TextDecoderStream': false; + readonly 'TextEncoder': false; + readonly 'TextEncoderStream': false; + readonly 'TextMetrics': false; + readonly 'TransformStream': false; + readonly 'TransformStreamDefaultController': false; + readonly 'TrustedHTML': false; + readonly 'TrustedScript': false; + readonly 'TrustedScriptURL': false; + readonly 'TrustedTypePolicy': false; + readonly 'TrustedTypePolicyFactory': false; + readonly 'trustedTypes': false; + readonly 'URL': false; + readonly 'URLPattern': false; + readonly 'URLSearchParams': false; + readonly 'USB': false; + readonly 'USBAlternateInterface': false; + readonly 'USBConfiguration': false; + readonly 'USBConnectionEvent': false; + readonly 'USBDevice': false; + readonly 'USBEndpoint': false; + readonly 'USBInterface': false; + readonly 'USBInTransferResult': false; + readonly 'USBIsochronousInTransferPacket': false; + readonly 'USBIsochronousInTransferResult': false; + readonly 'USBIsochronousOutTransferPacket': false; + readonly 'USBIsochronousOutTransferResult': false; + readonly 'USBOutTransferResult': false; + readonly 'UserActivation': false; + readonly 'VideoColorSpace': false; + readonly 'VideoDecoder': false; + readonly 'VideoEncoder': false; + readonly 'VideoFrame': false; + readonly 'WebAssembly': false; + readonly 'WebGL2RenderingContext': false; + readonly 'WebGLActiveInfo': false; + readonly 'WebGLBuffer': false; + readonly 'WebGLContextEvent': false; + readonly 'WebGLFramebuffer': false; + readonly 'WebGLObject': false; + readonly 'WebGLProgram': false; + readonly 'WebGLQuery': false; + readonly 'WebGLRenderbuffer': false; + readonly 'WebGLRenderingContext': false; + readonly 'WebGLSampler': false; + readonly 'WebGLShader': false; + readonly 'WebGLShaderPrecisionFormat': false; + readonly 'WebGLSync': false; + readonly 'WebGLTexture': false; + readonly 'WebGLTransformFeedback': false; + readonly 'WebGLUniformLocation': false; + readonly 'WebGLVertexArrayObject': false; + readonly 'webkitRequestFileSystem': false; + readonly 'webkitRequestFileSystemSync': false; + readonly 'webkitResolveLocalFileSystemSyncURL': false; + readonly 'webkitResolveLocalFileSystemURL': false; + readonly 'WebSocket': false; + readonly 'WebSocketError': false; + readonly 'WebSocketStream': false; + readonly 'WebTransport': false; + readonly 'WebTransportBidirectionalStream': false; + readonly 'WebTransportDatagramDuplexStream': false; + readonly 'WebTransportError': false; + readonly 'WGSLLanguageFeatures': false; + readonly 'when': false; + readonly 'Worker': false; + readonly 'WorkerGlobalScope': false; + readonly 'WorkerLocation': false; + readonly 'WorkerNavigator': false; + readonly 'WritableStream': false; + readonly 'WritableStreamDefaultController': false; + readonly 'WritableStreamDefaultWriter': false; + readonly 'XMLHttpRequest': false; + readonly 'XMLHttpRequestEventTarget': false; + readonly 'XMLHttpRequestUpload': false; +} + +type GlobalsWsh = { + readonly 'ActiveXObject': false; + readonly 'CollectGarbage': false; + readonly 'Debug': false; + readonly 'Enumerator': false; + readonly 'GetObject': false; + readonly 'RuntimeObject': false; + readonly 'ScriptEngine': false; + readonly 'ScriptEngineBuildVersion': false; + readonly 'ScriptEngineMajorVersion': false; + readonly 'ScriptEngineMinorVersion': false; + readonly 'VBArray': false; + readonly 'WScript': false; + readonly 'WSH': false; +} + +type GlobalsYui = { + readonly 'YAHOO': false; + readonly 'YAHOO_config': false; + readonly 'YUI': false; + readonly 'YUI_config': false; +} + +type Globals = { + readonly 'amd': GlobalsAmd; + readonly 'applescript': GlobalsApplescript; + readonly 'astro': GlobalsAstro; + readonly 'atomtest': GlobalsAtomtest; + readonly 'browser': GlobalsBrowser; + readonly 'builtin': GlobalsBuiltin; + readonly 'chai': GlobalsChai; + readonly 'commonjs': GlobalsCommonjs; + readonly 'couch': GlobalsCouch; + readonly 'devtools': GlobalsDevtools; + readonly 'embertest': GlobalsEmbertest; + readonly 'es2015': GlobalsEs2015; + readonly 'es2016': GlobalsEs2016; + readonly 'es2017': GlobalsEs2017; + readonly 'es2018': GlobalsEs2018; + readonly 'es2019': GlobalsEs2019; + readonly 'es2020': GlobalsEs2020; + readonly 'es2021': GlobalsEs2021; + readonly 'es2022': GlobalsEs2022; + readonly 'es2023': GlobalsEs2023; + readonly 'es2024': GlobalsEs2024; + readonly 'es2025': GlobalsEs2025; + readonly 'es2026': GlobalsEs2026; + readonly 'es3': GlobalsEs3; + readonly 'es5': GlobalsEs5; + readonly 'greasemonkey': GlobalsGreasemonkey; + readonly 'jasmine': GlobalsJasmine; + readonly 'jest': GlobalsJest; + readonly 'jquery': GlobalsJquery; + readonly 'meteor': GlobalsMeteor; + readonly 'mocha': GlobalsMocha; + readonly 'mongo': GlobalsMongo; + readonly 'nashorn': GlobalsNashorn; + readonly 'node': GlobalsNode; + readonly 'nodeBuiltin': GlobalsNodeBuiltin; + readonly 'phantomjs': GlobalsPhantomjs; + readonly 'prototypejs': GlobalsPrototypejs; + readonly 'protractor': GlobalsProtractor; + readonly 'qunit': GlobalsQunit; + readonly 'rhino': GlobalsRhino; + readonly 'serviceworker': GlobalsServiceworker; + readonly 'shared-node-browser': GlobalsSharednodebrowser; + readonly 'shelljs': GlobalsShelljs; + readonly 'svelte': GlobalsSvelte; + readonly 'vitest': GlobalsVitest; + readonly 'vue': GlobalsVue; + readonly 'webextensions': GlobalsWebextensions; + readonly 'worker': GlobalsWorker; + readonly 'wsh': GlobalsWsh; + readonly 'yui': GlobalsYui; +} + +declare const globals: Globals; + +export = globals; \ No newline at end of file diff --git a/tools/ui/node_modules/globals/index.js b/tools/ui/node_modules/globals/index.js new file mode 100644 index 0000000000000000000000000000000000000000..a951582e4176e860fdc0c9931723199310ad3d5b --- /dev/null +++ b/tools/ui/node_modules/globals/index.js @@ -0,0 +1,2 @@ +'use strict'; +module.exports = require('./globals.json'); diff --git a/tools/ui/node_modules/globals/license b/tools/ui/node_modules/globals/license new file mode 100644 index 0000000000000000000000000000000000000000..fa7ceba3eb4a9657a9db7f3ffca4e4e97a9019de --- /dev/null +++ b/tools/ui/node_modules/globals/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (https://sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/globals/package.json b/tools/ui/node_modules/globals/package.json new file mode 100644 index 0000000000000000000000000000000000000000..9b2199e924c822536cfdf8260b2bc1b496486643 --- /dev/null +++ b/tools/ui/node_modules/globals/package.json @@ -0,0 +1,117 @@ +{ + "name": "globals", + "version": "16.5.0", + "description": "Global identifiers from different JavaScript environments", + "license": "MIT", + "repository": "sindresorhus/globals", + "funding": "https://github.com/sponsors/sindresorhus", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "https://sindresorhus.com" + }, + "sideEffects": false, + "engines": { + "node": ">=18" + }, + "scripts": { + "test": "npm run build && xo && ava && tsd", + "prepare": "npm run build", + "update": "node scripts/update.mjs", + "update:browser": "node scripts/update.mjs --job=browser", + "update:builtin": "node scripts/update.mjs --job=builtin", + "update:builtin-yearly": "node scripts/update.mjs --job=builtin-yearly", + "update:nodeBuiltin": "node scripts/update.mjs --job=nodeBuiltin", + "update:worker": "node scripts/update.mjs --job=worker", + "update:serviceworker": "node scripts/update.mjs --job=serviceworker", + "update:shelljs": "node scripts/update.mjs --job=shelljs", + "update:jest": "node scripts/update.mjs --job=jest", + "update:vitest": "node scripts/update.mjs --job=vitest", + "build": "run-s build:data build:types", + "build:data": "node scripts/generate-data.mjs", + "build:types": "node scripts/generate-types.mjs" + }, + "files": [ + "index.js", + "index.d.ts", + "globals.json" + ], + "keywords": [ + "globals", + "global", + "identifiers", + "variables", + "vars", + "jshint", + "eslint", + "environments" + ], + "devDependencies": { + "@vitest/eslint-plugin": "^1.1.44", + "ava": "^6.3.0", + "cheerio": "^1.0.0", + "eslint-plugin-jest": "^28.11.0", + "get-port": "^7.1.0", + "is-identifier": "^1.0.1", + "nano-spawn": "^0.2.0", + "npm-run-all2": "^8.0.1", + "outdent": "^0.8.0", + "puppeteer": "^24.27.0", + "shelljs": "^0.9.2", + "tsd": "^0.32.0", + "type-fest": "^4.41.0", + "xo": "^0.60.0" + }, + "xo": { + "rules": { + "unicorn/prefer-module": "off" + }, + "overrides": [ + { + "files": [ + "data/*.mjs" + ], + "rules": { + "import/no-anonymous-default-export": "off", + "camelcase": "off", + "unicorn/filename-case": [ + "error", + { + "cases": { + "camelCase": true, + "kebabCase": true + } + } + ] + } + }, + { + "files": [ + "scripts/*.mjs" + ], + "rules": { + "n/no-unsupported-features/node-builtins": "off" + } + }, + { + "files": [ + "scripts/browser/assets/**/*.mjs" + ], + "envs": [ + "browser", + "worker", + "serviceworker" + ], + "rules": { + "n/no-unsupported-features/node-builtins": "off", + "unicorn/prefer-add-event-listener": "off" + } + } + ] + }, + "tsd": { + "compilerOptions": { + "resolveJsonModule": true + } + } +} diff --git a/tools/ui/node_modules/globals/readme.md b/tools/ui/node_modules/globals/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..3407019da7c9fa1cda5f4139b7abc30e79c45899 --- /dev/null +++ b/tools/ui/node_modules/globals/readme.md @@ -0,0 +1,42 @@ +# globals + +> Global identifiers from different JavaScript environments + +It's just a [JSON file](globals.json), so you can use it in any environment. + +This package is used by ESLint 8 and earlier. For ESLint 9 and later, you should depend on this package directly in [your ESLint config](https://eslint.org/docs/latest/use/configure/language-options#predefined-global-variables). + +## Install + +```sh +npm install globals +``` + +## Usage + +```js +import globals from 'globals'; + +console.log(globals.browser); +/* +{ + addEventListener: false, + applicationCache: false, + ArrayBuffer: false, + atob: false, + … +} +*/ +``` + +Each global is given a value of `true` or `false`. A value of `true` indicates that the variable may be overwritten. A value of `false` indicates that the variable should be considered read-only. This information is used by static analysis tools to flag incorrect behavior. We assume all variables should be `false` unless we hear otherwise. + +For Node.js this package provides two sets of globals: + +- `globals.nodeBuiltin`: Globals available to all code running in Node.js. + These will usually be available as properties on the `globalThis` object and include `process`, `Buffer`, but not CommonJS arguments like `require`. + See: https://nodejs.org/api/globals.html +- `globals.node`: A combination of the globals from `nodeBuiltin` plus all CommonJS arguments ("CommonJS module scope"). + See: https://nodejs.org/api/modules.html#modules_the_module_scope + +When analyzing code that is known to run outside of a CommonJS wrapper, for example, JavaScript modules, `nodeBuiltin` can find accidental CommonJS references. diff --git a/tools/ui/node_modules/globalthis/.eslintrc b/tools/ui/node_modules/globalthis/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..afbd40a7d774c788672c1d976d29b7a7f7208088 --- /dev/null +++ b/tools/ui/node_modules/globalthis/.eslintrc @@ -0,0 +1,18 @@ +{ + "root": true, + + "extends": "@ljharb", + + "env": { + "browser": true, + "node": true, + }, + + "ignorePatterns": [ + "dist", + ], + + "rules": { + "max-statements-per-line": [2, { "max": 2 }] + } +} diff --git a/tools/ui/node_modules/globalthis/.nycrc b/tools/ui/node_modules/globalthis/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..726d82ba29ae2b7a55b817325ae603692452d38a --- /dev/null +++ b/tools/ui/node_modules/globalthis/.nycrc @@ -0,0 +1,10 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "dist", + "test" + ] +} diff --git a/tools/ui/node_modules/globalthis/CHANGELOG.md b/tools/ui/node_modules/globalthis/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..1d44266f67b8d49088ea02cb65648e6967a0c811 --- /dev/null +++ b/tools/ui/node_modules/globalthis/CHANGELOG.md @@ -0,0 +1,109 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.0.4](https://github.com/es-shims/globalThis/compare/v1.0.3...v1.0.4) - 2024-04-29 + +### Commits + +- [actions] remove redundant finisher [`280d796`](https://github.com/es-shims/globalThis/commit/280d796f7cd61da47c026d8ec8dd88015d4ed95f) +- [Refactor] use `gopd` [`0209ccb`](https://github.com/es-shims/globalThis/commit/0209ccb2cd95b785e7e8868fab035cdc87216b58) +- [actions] update rebase action to use reusable workflow [`c08aea6`](https://github.com/es-shims/globalThis/commit/c08aea6240c3747cbc3e5f4d7c3eb740ec4f0627) +- [Dev Deps] update `@es-shims/api`, `@ljharb/eslint-config`, `aud`, `tape` [`f38f2af`](https://github.com/es-shims/globalThis/commit/f38f2af14797abbe466b428f0ce74843c43746d7) +- [Dev Deps] update `aud`, `tape` [`a1be102`](https://github.com/es-shims/globalThis/commit/a1be102c91da38830a45804de6a0582f752fe53f) +- [Deps] update `define-properties` [`3e41644`](https://github.com/es-shims/globalThis/commit/3e416444f87350a6df70bf778e95eb713c3011e6) +- [Deps] update `define-properties` [`3d81f70`](https://github.com/es-shims/globalThis/commit/3d81f7048ce35285e3e719b1f53fba02516e9811) +- [Dev Deps] add missing `npmignore` dep [`c2d00f7`](https://github.com/es-shims/globalThis/commit/c2d00f70d4c11cb2f035c398cb560db9677b6dc6) + +## [v1.0.3](https://github.com/es-shims/globalThis/compare/v1.0.2...v1.0.3) - 2022-05-07 + +### Commits + +- [actions] reuse common workflows [`65891e4`](https://github.com/es-shims/globalThis/commit/65891e4d285ae04e216ff01160cff861e0e41a4f) +- [actions] use `node/install` instead of `node/run`; use `codecov` action [`82f8481`](https://github.com/es-shims/globalThis/commit/82f84815027f666f625e1ccb41f723800a05d016) +- [meta] use `npmignore` to autogenerate an npmignore file [`53afc39`](https://github.com/es-shims/globalThis/commit/53afc39bfd3eb262c5e6e9dfd25e4f81f3578c1c) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `tape` [`03169d4`](https://github.com/es-shims/globalThis/commit/03169d4254c9ef177d6537becca5b0b56df50d91) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `safe-publish-latest`, `tape` [`4986e3e`](https://github.com/es-shims/globalThis/commit/4986e3e20c5f664601871a0fac68c1efd0a68472) +- [actions] update codecov uploader [`15c4b06`](https://github.com/es-shims/globalThis/commit/15c4b062b1a9434dbec93604ed31b6893d11d458) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `auto-changelog`, `tape` [`8b04a74`](https://github.com/es-shims/globalThis/commit/8b04a749d3cb2f825920beb700899f0c13ad2fb8) +- [Fix] `globalThis` should be writable [`8759985`](https://github.com/es-shims/globalThis/commit/87599852d5f91e2e1f06e424cdefcd443ec98476) +- [readme] add github actions/codecov badges [`0263f0d`](https://github.com/es-shims/globalThis/commit/0263f0debfa982b928fcd301b11fe3e3193bf33d) +- [Dev Deps] update `aud`, `eslint`, `tape` [`e88d296`](https://github.com/es-shims/globalThis/commit/e88d296bb026633bdd1be2e1542903a5d0107cd8) +- [meta] use `prepublishOnly` script for npm 7+ [`c81fde6`](https://github.com/es-shims/globalThis/commit/c81fde6a9e44345e56dada588e16db736809ddd9) +- [Tests] nycignore `dist` [`bde0c0d`](https://github.com/es-shims/globalThis/commit/bde0c0df46f684316ab414da1487a0cd2efe3eeb) +- [meta] gitignore coverage output [`79f73f8`](https://github.com/es-shims/globalThis/commit/79f73f8b0c1180567fba473f92c07d71efd4dd0b) + +## [v1.0.2](https://github.com/es-shims/globalThis/compare/v1.0.1...v1.0.2) - 2021-02-22 + +### Commits + +- [Tests] migrate tests to Github Actions [`a3f50f7`](https://github.com/es-shims/globalThis/commit/a3f50f77a392c0ffdaca18fb5881743b874d0a6f) +- [meta] do not publish github action workflow files [`eb5c787`](https://github.com/es-shims/globalThis/commit/eb5c7879317cd7f1fde52228660be8e779c9d4e3) +- [Tests] add `implementation` est; run `es-shim-api` in postlint; use `tape` runner [`c9dd792`](https://github.com/es-shims/globalThis/commit/c9dd792d492ec9744a5e5d5033e919b94d441bac) +- [Tests] fix native tests [`6b76dff`](https://github.com/es-shims/globalThis/commit/6b76dff3af3fe9bcd7b24d48c6ba55116169e840) +- [Tests] run `nyc` on all tests [`0407f79`](https://github.com/es-shims/globalThis/commit/0407f79f64bf9fc30111f3bf4dff7e4205331fb6) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `tape`, `browserify` [`b8cc020`](https://github.com/es-shims/globalThis/commit/b8cc020e5ecc2d5a5a5b4160aabc60cc42d50c03) +- [actions] add "Allow Edits" workflow [`e2854df`](https://github.com/es-shims/globalThis/commit/e2854df653667b16ff34a7a0a7b677231dfe2b02) +- [readme] remove travis badge [`262eb76`](https://github.com/es-shims/globalThis/commit/262eb76e4e0d3f2df354cc6aff1b18f50c7b147f) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`; add `safe-publish-latest` [`3c76883`](https://github.com/es-shims/globalThis/commit/3c7688325f6aa050afe3ed978e423e70974e4d3b) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`7276123`](https://github.com/es-shims/globalThis/commit/727612396262fc22275f44159ec5b39115dc359f) +- [actions] update workflows [`bcb0f42`](https://github.com/es-shims/globalThis/commit/bcb0f42c319cf19746e03a6667cf25d3e835f46e) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` [`5485851`](https://github.com/es-shims/globalThis/commit/548585148e874d6eb0b0463526a88e8b64e7c5eb) +- [Dev Deps] update `auto-changelog`, `tape` [`6a01da3`](https://github.com/es-shims/globalThis/commit/6a01da3f321983d1970d793711d31cf8508ef94d) +- [Dev Deps] update `@ljharb/eslint-config`, `tape` [`7a07f4e`](https://github.com/es-shims/globalThis/commit/7a07f4ebc5580933b40bbe67f357632e0f7d5586) +- [meta] only run the build script in publish [`797e492`](https://github.com/es-shims/globalThis/commit/797e492519ed0bf6270537290e69ca0456790575) +- [meta] combine duplicate `prepublish` scripts [`92bbef0`](https://github.com/es-shims/globalThis/commit/92bbef0f91f6e91163186f68b5f5f1ffd26c479d) +- [Dev Deps] update `auto-changelog`; add `aud` [`be6dbec`](https://github.com/es-shims/globalThis/commit/be6dbecefddb40493c5568a2cbe83f74e2e0385f) +- [actions] switch Automatic Rebase workflow to `pull_request_target` event [`bfd54f8`](https://github.com/es-shims/globalThis/commit/bfd54f8388758e7dec618dc34956e7075a7c15f0) +- [Tests] only audit prod deps [`0f64b47`](https://github.com/es-shims/globalThis/commit/0f64b47acfa812affbacbe487fcb0f6c02eccc25) + +## [v1.0.1](https://github.com/es-shims/globalThis/compare/v1.0.0...v1.0.1) - 2019-12-15 + +### Fixed + +- [Refactor] only use `global` in node; only check browser globals in browsers [`#2`](https://github.com/es-shims/globalThis/issues/2) + +### Commits + +- [Tests] use shared travis-ci configs [`edb1cc9`](https://github.com/es-shims/globalThis/commit/edb1cc9d900a40e8c1732264b6e85d4f9760920c) +- [Tests] remove `jscs` [`1847ac2`](https://github.com/es-shims/globalThis/commit/1847ac2487e2c13cf8bf717211c6a93fe60831f9) +- [meta] add `auto-changelog` [`933c381`](https://github.com/es-shims/globalThis/commit/933c381083890965ac848d3da21ed9e910cc09cf) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `browserify`, `tape` [`93310bc`](https://github.com/es-shims/globalThis/commit/93310bc01ddacbe23a93b3022daebc9b6f6ae8c3) +- [actions] add automatic rebasing / merge commit blocking [`231dec5`](https://github.com/es-shims/globalThis/commit/231dec511c42e1509035d176e2451c55de20bfe7) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `browserify`, `covert`, `is`, `tape` [`e50c1f6`](https://github.com/es-shims/globalThis/commit/e50c1f6d2d45c66f53ffda471bbf62c08ed15c9b) +- [Tests] use `npx aud` instead of `nsp` or `npm audit` with hoops [`4abd340`](https://github.com/es-shims/globalThis/commit/4abd3400fc8942963e77515d0cf2fbcac3cb7bc8) +- [meta] add `funding` field [`2d1f9eb`](https://github.com/es-shims/globalThis/commit/2d1f9eb00b2dea46f6de7d563b31db17f44f1899) +- [meta] remove unused deps [`5bd6bef`](https://github.com/es-shims/globalThis/commit/5bd6befefbaf0c7e6f70eb3c1919b5c5a271d29d) +- readme: Fix casing + phrasing [`66379cc`](https://github.com/es-shims/globalThis/commit/66379ccf5008f7676aac5f3dec1ea2fe55e3516c) +- [Deps] update `define-properties`, `object-keys` [`4585e5a`](https://github.com/es-shims/globalThis/commit/4585e5ab461093ab6c62ce0b22b959925e8f818c) +- fix issue with Webpack's CaseSensitivePathsPlugin [`842e84e`](https://github.com/es-shims/globalThis/commit/842e84e0096c9eea660c78fd19c9c07799b81537) + +## v1.0.0 - 2018-08-10 + +### Commits + +- Dotfiles. [`f01b02d`](https://github.com/es-shims/globalThis/commit/f01b02d315865c812e5b9158f71bb18f3b153def) +- [Tests] up to `node` `v10.7`, `v9.11`, `v8.11`, `v7.10`, `v6.14`, `v4.9`; use `nvm install-latest-npm`; improve matrix [`ed1fa5d`](https://github.com/es-shims/globalThis/commit/ed1fa5d473d933b3270410b658183dc1c556a663) +- Tests [`ab99527`](https://github.com/es-shims/globalThis/commit/ab99527e3c434e89dd40f8cba3b0e2e976156611) +- [breaking] update property name, rename repo [`be42e3d`](https://github.com/es-shims/globalThis/commit/be42e3dce08b62a78260d487f62fa69b410d7918) +- package.json [`ca43a36`](https://github.com/es-shims/globalThis/commit/ca43a363e3ce0dbc2d4623169f8cb3d792f8bc84) +- implementation [`80b5a40`](https://github.com/es-shims/globalThis/commit/80b5a403ef532254b2af46ec3ba5f442a308a57d) +- read me [`f6df9b3`](https://github.com/es-shims/globalThis/commit/f6df9b3b69977f04e080d1720ba1203c13447884) +- Rename `System.global` to `global` [`fa8503c`](https://github.com/es-shims/globalThis/commit/fa8503cf94afe84b3729dd5b0e9f73f481fb1fee) +- Initial commit [`99f1dc3`](https://github.com/es-shims/globalThis/commit/99f1dc328d0b4c52a550037de0139d5452ac01de) +- [Tests] up to `node` `v6.7`, `v5.12`, `v4.6`; improve test matrix [`712ec0e`](https://github.com/es-shims/globalThis/commit/712ec0e545d1603c4e23f4ff1acb066cc4a3c9ee) +- [Dev Deps] update `browserify`, `tape`, `jscs`, `nsp`, `eslint`, `@ljharb/eslint-config` [`73278bd`](https://github.com/es-shims/globalThis/commit/73278bd638d1e762eb7415350a738f5d345896f5) +- [Dev Deps] update `@es-shims/api`, `@ljharb/eslint-config`, `browserify`, `eslint`, `for-each`, `is`, `nsp`, `tape` [`75fa992`](https://github.com/es-shims/globalThis/commit/75fa9929be81afec43895c02e33d0b8a78f11d1f) +- [Dev Deps] update `browserify`, `is`, `tape`, `nsp`, `eslint` [`b223e86`](https://github.com/es-shims/globalThis/commit/b223e86d0868efb1f0c966370ff2f822516d6956) +- [Tests] fix linting; remove parallelshell [`271b329`](https://github.com/es-shims/globalThis/commit/271b329d174b94c08913060752a2e9f9116fe5b8) +- [Deps] update `function-bind`, `object-keys` [`002d0c5`](https://github.com/es-shims/globalThis/commit/002d0c5685a83f97e014a8a07134eb621794c649) +- Only apps should have lockfiles [`960f1d0`](https://github.com/es-shims/globalThis/commit/960f1d00598cbba5427849c863eb10b8de82fb1b) +- [Tests] on `node` `v10.8` [`37fad9d`](https://github.com/es-shims/globalThis/commit/37fad9db9860c654efe0a32ec187f21730d5fed8) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config` [`df28dfe`](https://github.com/es-shims/globalThis/commit/df28dfe7f0daf3db95a536a6ce64062bd706185d) +- [New] add `auto` entry point [`86eb2ab`](https://github.com/es-shims/globalThis/commit/86eb2ab4c4dc2babff20ac436cf7fb7f8da7d2f2) +- [Dev Deps] update `eslint` [`1bdc1aa`](https://github.com/es-shims/globalThis/commit/1bdc1aacfb94dcdc7bb61688c7634c435012e35d) +- [Deps] update `object-keys` [`72cdbf5`](https://github.com/es-shims/globalThis/commit/72cdbf596b16103ee711d52b2b645b42efc08c51) +- Update most common usage to invoke the function upon being required [`5026296`](https://github.com/es-shims/globalThis/commit/502629660da2c21cfb0f8ca233e2b9d427c052fe) diff --git a/tools/ui/node_modules/globalthis/LICENSE b/tools/ui/node_modules/globalthis/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..44f679ad414f6f5d5b0c510a2ce31dfe811e5d47 --- /dev/null +++ b/tools/ui/node_modules/globalthis/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2016 Jordan Harband + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/globalthis/README.md b/tools/ui/node_modules/globalthis/README.md new file mode 100644 index 0000000000000000000000000000000000000000..6abffa03395be4829a58e9b96b0bd26171855700 --- /dev/null +++ b/tools/ui/node_modules/globalthis/README.md @@ -0,0 +1,70 @@ +# globalThis [![Version Badge][npm-version-svg]][npm-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][npm-url] + +An ECMAScript spec-compliant polyfill/shim for `globalThis`. Invoke its "shim" method to shim `globalThis` if it is unavailable. + +This package implements the [es-shim API](https://github.com/es-shims/api) interface. It works in an ES3-supported environment and complies with the [spec proposal](https://github.com/tc39/proposal-global). + +Most common usage: +```js +var globalThis = require('globalthis')(); // returns native globalThis if compliant + /* or */ +var globalThis = require('globalthis/polyfill')(); // returns native globalThis if compliant +``` + +## Example + +```js +var assert = require('assert'); + +// the below function is not CSP-compliant, but reliably gets the +// global object in sloppy mode in every engine. +var getGlobal = Function('return this'); + +assert.equal(globalThis, getGlobal()); +``` + +```js +/* when `globalThis` is not present */ +var shimmedGlobal = require('globalthis').shim(); + /* or */ +var shimmedGlobal = require('globalthis/shim')(); + +assert.equal(shimmedGlobal, globalThis); +assert.equal(shimmedGlobal, getGlobal()); +``` + +```js +/* when `globalThis` is present */ +var shimmedGlobal = require('globalthis').shim(); + +assert.equal(shimmedGlobal, globalThis); +assert.equal(shimmedGlobal, getGlobal()); +``` + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[npm-url]: https://npmjs.org/package/globalthis +[npm-version-svg]: https://versionbadg.es/ljharb/globalThis.svg +[deps-svg]: https://david-dm.org/ljharb/globalThis.svg?theme=shields.io +[deps-url]: https://david-dm.org/ljharb/globalThis +[dev-deps-svg]: https://david-dm.org/ljharb/globalThis/dev-status.svg?theme=shields.io +[dev-deps-url]: https://david-dm.org/ljharb/globalThis#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/globalthis.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/globalthis.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/globalthis.svg +[downloads-url]: https://npm-stat.com/charts.html?package=globalthis +[codecov-image]: https://codecov.io/gh/es-shims/globalThis/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/es-shims/globalThis/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/es-shims/globalThis +[actions-url]: https://github.com/es-shims/globalThis/actions diff --git a/tools/ui/node_modules/globalthis/auto.js b/tools/ui/node_modules/globalthis/auto.js new file mode 100644 index 0000000000000000000000000000000000000000..8ebf606cb02ff3a8c6ef786afa37d21a19254f46 --- /dev/null +++ b/tools/ui/node_modules/globalthis/auto.js @@ -0,0 +1,3 @@ +'use strict'; + +require('./shim')(); diff --git a/tools/ui/node_modules/globalthis/implementation.browser.js b/tools/ui/node_modules/globalthis/implementation.browser.js new file mode 100644 index 0000000000000000000000000000000000000000..746a274d94c57e48b0126eb00fd0c8901269cfc2 --- /dev/null +++ b/tools/ui/node_modules/globalthis/implementation.browser.js @@ -0,0 +1,11 @@ +/* eslint no-negated-condition: 0, no-new-func: 0 */ + +'use strict'; + +if (typeof self !== 'undefined') { + module.exports = self; +} else if (typeof window !== 'undefined') { + module.exports = window; +} else { + module.exports = Function('return this')(); +} diff --git a/tools/ui/node_modules/globalthis/implementation.js b/tools/ui/node_modules/globalthis/implementation.js new file mode 100644 index 0000000000000000000000000000000000000000..46b8ceb3ae586184c701efa25d35962495559171 --- /dev/null +++ b/tools/ui/node_modules/globalthis/implementation.js @@ -0,0 +1,3 @@ +'use strict'; + +module.exports = global; diff --git a/tools/ui/node_modules/globalthis/index.js b/tools/ui/node_modules/globalthis/index.js new file mode 100644 index 0000000000000000000000000000000000000000..7c73cef2e86a0e5b265b1bc95fc4442549b7931e --- /dev/null +++ b/tools/ui/node_modules/globalthis/index.js @@ -0,0 +1,19 @@ +'use strict'; + +var defineProperties = require('define-properties'); + +var implementation = require('./implementation'); +var getPolyfill = require('./polyfill'); +var shim = require('./shim'); + +var polyfill = getPolyfill(); + +var getGlobal = function () { return polyfill; }; + +defineProperties(getGlobal, { + getPolyfill: getPolyfill, + implementation: implementation, + shim: shim +}); + +module.exports = getGlobal; diff --git a/tools/ui/node_modules/globalthis/package.json b/tools/ui/node_modules/globalthis/package.json new file mode 100644 index 0000000000000000000000000000000000000000..4a90d3d1562b56c2ba0c32c9de92c011b08416b6 --- /dev/null +++ b/tools/ui/node_modules/globalthis/package.json @@ -0,0 +1,99 @@ +{ + "name": "globalthis", + "version": "1.0.4", + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "description": "ECMAScript spec-compliant polyfill/shim for `globalThis`", + "license": "MIT", + "main": "index.js", + "browser": { + "./implementation": "./implementation.browser.js" + }, + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublishOnly": "safe-publish-latest && npm run build", + "prepublish": "not-in-publish || npm run prepublishOnly", + "pretest": "npm run lint", + "test": "npm run --silent tests-only", + "posttest": "aud --production", + "tests-only": "nyc tape 'test/**/*.js'", + "lint": "eslint --ext=js,mjs .", + "postlint": "es-shim-api --bound --property", + "build": "mkdir -p dist && browserify browserShim.js > dist/browser.js", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git://github.com/ljharb/System.global.git" + }, + "keywords": [ + "window", + "self", + "global", + "globalThis", + "System.global", + "global object", + "global this value", + "ECMAScript", + "es-shim API", + "polyfill", + "shim" + ], + "dependencies": { + "define-properties": "^1.2.1", + "gopd": "^1.0.1" + }, + "devDependencies": { + "@es-shims/api": "^2.5.0", + "@ljharb/eslint-config": "^21.1.0", + "aud": "^2.0.4", + "auto-changelog": "^2.4.0", + "browserify": "^16.5.2", + "eslint": "=8.8.0", + "for-each": "^0.3.3", + "in-publish": "^2.0.1", + "is": "^3.3.0", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "tape": "^5.7.5" + }, + "testling": { + "files": "test/index.js", + "browsers": [ + "iexplore/6.0..latest", + "firefox/3.0..6.0", + "firefox/15.0..latest", + "firefox/nightly", + "chrome/4.0..10.0", + "chrome/20.0..latest", + "chrome/canary", + "opera/10.0..latest", + "opera/next", + "safari/4.0..latest", + "ipad/6.0..latest", + "iphone/6.0..latest", + "android-browser/4.2" + ] + }, + "engines": { + "node": ">= 0.4" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + "browserShim.js", + ".github/workflows" + ] + } +} diff --git a/tools/ui/node_modules/globalthis/polyfill.js b/tools/ui/node_modules/globalthis/polyfill.js new file mode 100644 index 0000000000000000000000000000000000000000..e2e706bd53b98644147fa43c405f0aef44be4485 --- /dev/null +++ b/tools/ui/node_modules/globalthis/polyfill.js @@ -0,0 +1,10 @@ +'use strict'; + +var implementation = require('./implementation'); + +module.exports = function getPolyfill() { + if (typeof global !== 'object' || !global || global.Math !== Math || global.Array !== Array) { + return implementation; + } + return global; +}; diff --git a/tools/ui/node_modules/globalthis/shim.js b/tools/ui/node_modules/globalthis/shim.js new file mode 100644 index 0000000000000000000000000000000000000000..ee89bbb2ee1da59a14bf3ae327e62c4001cdf1a9 --- /dev/null +++ b/tools/ui/node_modules/globalthis/shim.js @@ -0,0 +1,29 @@ +'use strict'; + +var define = require('define-properties'); +var gOPD = require('gopd'); +var getPolyfill = require('./polyfill'); + +module.exports = function shimGlobal() { + var polyfill = getPolyfill(); + if (define.supportsDescriptors) { + var descriptor = gOPD(polyfill, 'globalThis'); + if ( + !descriptor + || ( + descriptor.configurable + && (descriptor.enumerable || !descriptor.writable || globalThis !== polyfill) + ) + ) { + Object.defineProperty(polyfill, 'globalThis', { + configurable: true, + enumerable: false, + value: polyfill, + writable: true + }); + } + } else if (typeof globalThis !== 'object' || globalThis !== polyfill) { + polyfill.globalThis = polyfill; + } + return polyfill; +}; diff --git a/tools/ui/node_modules/globalthis/test/implementation.js b/tools/ui/node_modules/globalthis/test/implementation.js new file mode 100644 index 0000000000000000000000000000000000000000..36f1275bfd15fc9b33019ea91c7d3466ef8f46df --- /dev/null +++ b/tools/ui/node_modules/globalthis/test/implementation.js @@ -0,0 +1,11 @@ +'use strict'; + +var implementation = require('../implementation'); +var test = require('tape'); +var runTests = require('./tests'); + +test('implementation', function (t) { + runTests(implementation, t); + + t.end(); +}); diff --git a/tools/ui/node_modules/globalthis/test/index.js b/tools/ui/node_modules/globalthis/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..dac0a10a61df7bf1a640fb61c9e5b75a42f57a75 --- /dev/null +++ b/tools/ui/node_modules/globalthis/test/index.js @@ -0,0 +1,11 @@ +'use strict'; + +var systemGlobal = require('../'); +var test = require('tape'); +var runTests = require('./tests'); + +test('as a function', function (t) { + runTests(systemGlobal(), t); + + t.end(); +}); diff --git a/tools/ui/node_modules/globalthis/test/native.js b/tools/ui/node_modules/globalthis/test/native.js new file mode 100644 index 0000000000000000000000000000000000000000..7a085ab0a30c5ce050efa5e0708547486e2d9e80 --- /dev/null +++ b/tools/ui/node_modules/globalthis/test/native.js @@ -0,0 +1,26 @@ +'use strict'; + +var test = require('tape'); +var defineProperties = require('define-properties'); +var isEnumerable = Object.prototype.propertyIsEnumerable; + +var missing = {}; +var theGlobal = typeof globalThis === 'object' ? globalThis : missing; + +var runTests = require('./tests'); + +test('native', { todo: theGlobal === missing }, function (t) { + if (theGlobal !== missing) { + t.equal(typeof theGlobal, 'object', 'globalThis is an object'); + t.equal('globalThis' in theGlobal, true, 'globalThis is in globalThis'); + + t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) { + et.equal(false, isEnumerable.call(theGlobal, 'globalThis'), 'globalThis is not enumerable'); + et.end(); + }); + + runTests(theGlobal, t); + } + + t.end(); +}); diff --git a/tools/ui/node_modules/globalthis/test/shimmed.js b/tools/ui/node_modules/globalthis/test/shimmed.js new file mode 100644 index 0000000000000000000000000000000000000000..24b3f34d2dc3fb45a6a53984f3a39b2c7d4178cc --- /dev/null +++ b/tools/ui/node_modules/globalthis/test/shimmed.js @@ -0,0 +1,29 @@ +'use strict'; + +require('../auto'); + +var test = require('tape'); +var defineProperties = require('define-properties'); +var isEnumerable = Object.prototype.propertyIsEnumerable; + +var runTests = require('./tests'); + +test('shimmed', function (t) { + t.equal(typeof globalThis, 'object', 'globalThis is an object'); + t.equal('globalThis' in globalThis, true, 'globalThis is in globalThis'); + + t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) { + et.equal(false, isEnumerable.call(globalThis, 'globalThis'), 'globalThis.globalThis is not enumerable'); + et.end(); + }); + + t.test('writability', { skip: !defineProperties.supportsDescriptors }, function (wt) { + var desc = Object.getOwnPropertyDescriptor(globalThis, 'globalThis'); + wt.equal(desc.writable, true, 'globalThis.globalThis is writable'); + wt.end(); + }); + + runTests(globalThis.globalThis, t); + + t.end(); +}); diff --git a/tools/ui/node_modules/globalthis/test/tests.js b/tools/ui/node_modules/globalthis/test/tests.js new file mode 100644 index 0000000000000000000000000000000000000000..21896405400473065f1d6e494988af13be387214 --- /dev/null +++ b/tools/ui/node_modules/globalthis/test/tests.js @@ -0,0 +1,36 @@ +/* jscs:disable requireUseStrict */ +/* eslint strict: 0, max-statements: 0 */ + +module.exports = function (theGlobal, t) { + t.equal(typeof theGlobal, 'object', 'is an object'); + + t.test('built-in globals', function (st) { + st.equal(theGlobal.Math, Math, 'Math is on the global'); + st.equal(theGlobal.JSON, JSON, 'JSON is on the global'); + st.equal(theGlobal.String, String, 'String is on the global'); + st.equal(theGlobal.Array, Array, 'Array is on the global'); + st.equal(theGlobal.Number, Number, 'Number is on the global'); + st.equal(theGlobal.Boolean, Boolean, 'Boolean is on the global'); + st.equal(theGlobal.Object, Object, 'Object is on the global'); + st.equal(theGlobal.Function, Function, 'Function is on the global'); + st.equal(theGlobal.Date, Date, 'Date is on the global'); + st.equal(theGlobal.RegExp, RegExp, 'RegExp is on the global'); + + if (typeof Symbol === 'undefined') { + st.comment('# SKIP Symbol is not supported'); + } else { + st.equal(theGlobal.Symbol, Symbol, 'Symbol is on the global'); + } + st.end(); + }); + + t.test('custom property', function (st) { + var key = 'random_custom_key_' + new Date().getTime(); + var semaphore = {}; + /* eslint no-eval: 1 */ + eval(key + ' = semaphore;'); + st.equal(theGlobal[key], semaphore, 'global variable ends up on the global object'); + delete theGlobal[key]; // eslint-disable-line no-param-reassign + st.end(); + }); +}; diff --git a/tools/ui/node_modules/gopd/.eslintrc b/tools/ui/node_modules/gopd/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..e2550c0fb7e8a8b16191ac89b2aaab429948720d --- /dev/null +++ b/tools/ui/node_modules/gopd/.eslintrc @@ -0,0 +1,16 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "func-style": [2, "declaration"], + "id-length": 0, + "multiline-comment-style": 0, + "new-cap": [2, { + "capIsNewExceptions": [ + "GetIntrinsic", + ], + }], + }, +} diff --git a/tools/ui/node_modules/gopd/.github/FUNDING.yml b/tools/ui/node_modules/gopd/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..94a44a8e83ff69f9167af25ae71c238d0f07250e --- /dev/null +++ b/tools/ui/node_modules/gopd/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/gopd +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/gopd/CHANGELOG.md b/tools/ui/node_modules/gopd/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..87f5727fb65c35e7a75fe15464473ffc0455739b --- /dev/null +++ b/tools/ui/node_modules/gopd/CHANGELOG.md @@ -0,0 +1,45 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.2.0](https://github.com/ljharb/gopd/compare/v1.1.0...v1.2.0) - 2024-12-03 + +### Commits + +- [New] add `gOPD` entry point; remove `get-intrinsic` [`5b61232`](https://github.com/ljharb/gopd/commit/5b61232dedea4591a314bcf16101b1961cee024e) + +## [v1.1.0](https://github.com/ljharb/gopd/compare/v1.0.1...v1.1.0) - 2024-11-29 + +### Commits + +- [New] add types [`f585e39`](https://github.com/ljharb/gopd/commit/f585e397886d270e4ba84e53d226e4f9ca2eb0e6) +- [Dev Deps] update `@ljharb/eslint-config`, `auto-changelog`, `tape` [`0b8e4fd`](https://github.com/ljharb/gopd/commit/0b8e4fded64397a7726a9daa144a6cc9a5e2edfa) +- [Dev Deps] update `aud`, `npmignore`, `tape` [`48378b2`](https://github.com/ljharb/gopd/commit/48378b2443f09a4f7efbd0fb6c3ee845a6cabcf3) +- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `tape` [`78099ee`](https://github.com/ljharb/gopd/commit/78099eeed41bfdc134c912280483689cc8861c31) +- [Tests] replace `aud` with `npm audit` [`4e0d0ac`](https://github.com/ljharb/gopd/commit/4e0d0ac47619d24a75318a8e1f543ee04b2a2632) +- [meta] add missing `engines.node` [`1443316`](https://github.com/ljharb/gopd/commit/14433165d07835c680155b3dfd62d9217d735eca) +- [Deps] update `get-intrinsic` [`eee5f51`](https://github.com/ljharb/gopd/commit/eee5f51769f3dbaf578b70e2a3199116b01aa670) +- [Deps] update `get-intrinsic` [`550c378`](https://github.com/ljharb/gopd/commit/550c3780e3a9c77b62565712a001b4ed64ea61f5) +- [Dev Deps] add missing peer dep [`8c2ecf8`](https://github.com/ljharb/gopd/commit/8c2ecf848122e4e30abfc5b5086fb48b390dce75) + +## [v1.0.1](https://github.com/ljharb/gopd/compare/v1.0.0...v1.0.1) - 2022-11-01 + +### Commits + +- [Fix] actually export gOPD instead of dP [`4b624bf`](https://github.com/ljharb/gopd/commit/4b624bfbeff788c5e3ff16d9443a83627847234f) + +## v1.0.0 - 2022-11-01 + +### Commits + +- Initial implementation, tests, readme [`0911e01`](https://github.com/ljharb/gopd/commit/0911e012cd642092bd88b732c161c58bf4f20bea) +- Initial commit [`b84e33f`](https://github.com/ljharb/gopd/commit/b84e33f5808a805ac57ff88d4247ad935569acbe) +- [actions] add reusable workflows [`12ae28a`](https://github.com/ljharb/gopd/commit/12ae28ae5f50f86e750215b6e2188901646d0119) +- npm init [`280118b`](https://github.com/ljharb/gopd/commit/280118badb45c80b4483836b5cb5315bddf6e582) +- [meta] add `auto-changelog` [`bb78de5`](https://github.com/ljharb/gopd/commit/bb78de5639a180747fb290c28912beaaf1615709) +- [meta] create FUNDING.yml; add `funding` in package.json [`11c22e6`](https://github.com/ljharb/gopd/commit/11c22e6355bb01f24e7fac4c9bb3055eb5b25002) +- [meta] use `npmignore` to autogenerate an npmignore file [`4f4537a`](https://github.com/ljharb/gopd/commit/4f4537a843b39f698c52f072845092e6fca345bb) +- Only apps should have lockfiles [`c567022`](https://github.com/ljharb/gopd/commit/c567022a18573aa7951cf5399445d9840e23e98b) diff --git a/tools/ui/node_modules/gopd/LICENSE b/tools/ui/node_modules/gopd/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..6abfe1434ebd5c15c245b9f0a7c25e36b581df19 --- /dev/null +++ b/tools/ui/node_modules/gopd/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Jordan Harband + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/gopd/README.md b/tools/ui/node_modules/gopd/README.md new file mode 100644 index 0000000000000000000000000000000000000000..784e56a09695adb47410cb6cf08e96334a9f9c1f --- /dev/null +++ b/tools/ui/node_modules/gopd/README.md @@ -0,0 +1,40 @@ +# gopd [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +`Object.getOwnPropertyDescriptor`, but accounts for IE's broken implementation. + +## Usage + +```javascript +var gOPD = require('gopd'); +var assert = require('assert'); + +if (gOPD) { + assert.equal(typeof gOPD, 'function', 'descriptors supported'); + // use gOPD like Object.getOwnPropertyDescriptor here +} else { + assert.ok(!gOPD, 'descriptors not supported'); +} +``` + +[package-url]: https://npmjs.org/package/gopd +[npm-version-svg]: https://versionbadg.es/ljharb/gopd.svg +[deps-svg]: https://david-dm.org/ljharb/gopd.svg +[deps-url]: https://david-dm.org/ljharb/gopd +[dev-deps-svg]: https://david-dm.org/ljharb/gopd/dev-status.svg +[dev-deps-url]: https://david-dm.org/ljharb/gopd#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/gopd.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/gopd.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/gopd.svg +[downloads-url]: https://npm-stat.com/charts.html?package=gopd +[codecov-image]: https://codecov.io/gh/ljharb/gopd/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/ljharb/gopd/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/ljharb/gopd +[actions-url]: https://github.com/ljharb/gopd/actions diff --git a/tools/ui/node_modules/gopd/gOPD.d.ts b/tools/ui/node_modules/gopd/gOPD.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..def48a3ccd01ec119d6d996fb6070d82de1641a5 --- /dev/null +++ b/tools/ui/node_modules/gopd/gOPD.d.ts @@ -0,0 +1 @@ +export = Object.getOwnPropertyDescriptor; diff --git a/tools/ui/node_modules/gopd/gOPD.js b/tools/ui/node_modules/gopd/gOPD.js new file mode 100644 index 0000000000000000000000000000000000000000..cf9616c4a6671026d27790a79dbf26732a5860fb --- /dev/null +++ b/tools/ui/node_modules/gopd/gOPD.js @@ -0,0 +1,4 @@ +'use strict'; + +/** @type {import('./gOPD')} */ +module.exports = Object.getOwnPropertyDescriptor; diff --git a/tools/ui/node_modules/gopd/index.d.ts b/tools/ui/node_modules/gopd/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..e228065f3682d916a1474496f002a9c7bf23c2f4 --- /dev/null +++ b/tools/ui/node_modules/gopd/index.d.ts @@ -0,0 +1,5 @@ +declare function gOPD(obj: O, prop: K): PropertyDescriptor | undefined; + +declare const fn: typeof gOPD | undefined | null; + +export = fn; \ No newline at end of file diff --git a/tools/ui/node_modules/gopd/index.js b/tools/ui/node_modules/gopd/index.js new file mode 100644 index 0000000000000000000000000000000000000000..a4081b013e2a7f3406e47ff109bc0c454905b4cf --- /dev/null +++ b/tools/ui/node_modules/gopd/index.js @@ -0,0 +1,15 @@ +'use strict'; + +/** @type {import('.')} */ +var $gOPD = require('./gOPD'); + +if ($gOPD) { + try { + $gOPD([], 'length'); + } catch (e) { + // IE 8 has a broken gOPD + $gOPD = null; + } +} + +module.exports = $gOPD; diff --git a/tools/ui/node_modules/gopd/package.json b/tools/ui/node_modules/gopd/package.json new file mode 100644 index 0000000000000000000000000000000000000000..01c5ffa632971171f69bd06cf866d4a3be0db124 --- /dev/null +++ b/tools/ui/node_modules/gopd/package.json @@ -0,0 +1,77 @@ +{ + "name": "gopd", + "version": "1.2.0", + "description": "`Object.getOwnPropertyDescriptor`, but accounts for IE's broken implementation.", + "main": "index.js", + "exports": { + ".": "./index.js", + "./gOPD": "./gOPD.js", + "./package.json": "./package.json" + }, + "sideEffects": false, + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublishOnly": "safe-publish-latest", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prelint": "tsc -p . && attw -P", + "lint": "eslint --ext=js,mjs .", + "postlint": "evalmd README.md", + "pretest": "npm run lint", + "tests-only": "tape 'test/**/*.js'", + "test": "npm run tests-only", + "posttest": "npx npm@'>=10.2' audit --production", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/ljharb/gopd.git" + }, + "keywords": [ + "ecmascript", + "javascript", + "getownpropertydescriptor", + "property", + "descriptor" + ], + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/ljharb/gopd/issues" + }, + "homepage": "https://github.com/ljharb/gopd#readme", + "devDependencies": { + "@arethetypeswrong/cli": "^0.17.0", + "@ljharb/eslint-config": "^21.1.1", + "@ljharb/tsconfig": "^0.2.0", + "@types/tape": "^5.6.5", + "auto-changelog": "^2.5.0", + "encoding": "^0.1.13", + "eslint": "=8.8.0", + "evalmd": "^0.0.19", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0", + "typescript": "next" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + }, + "engines": { + "node": ">= 0.4" + } +} diff --git a/tools/ui/node_modules/gopd/test/index.js b/tools/ui/node_modules/gopd/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..6f43453ade2de4499935b80e16d47d7c1406dd2f --- /dev/null +++ b/tools/ui/node_modules/gopd/test/index.js @@ -0,0 +1,36 @@ +'use strict'; + +var test = require('tape'); +var gOPD = require('../'); + +test('gOPD', function (t) { + t.test('supported', { skip: !gOPD }, function (st) { + st.equal(typeof gOPD, 'function', 'is a function'); + + var obj = { x: 1 }; + st.ok('x' in obj, 'property exists'); + + // @ts-expect-error TS can't figure out narrowing from `skip` + var desc = gOPD(obj, 'x'); + st.deepEqual( + desc, + { + configurable: true, + enumerable: true, + value: 1, + writable: true + }, + 'descriptor is as expected' + ); + + st.end(); + }); + + t.test('not supported', { skip: !!gOPD }, function (st) { + st.notOk(gOPD, 'is falsy'); + + st.end(); + }); + + t.end(); +}); diff --git a/tools/ui/node_modules/gopd/tsconfig.json b/tools/ui/node_modules/gopd/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..d9a6668c3ae6be748c78fbd5694053706b3d6942 --- /dev/null +++ b/tools/ui/node_modules/gopd/tsconfig.json @@ -0,0 +1,9 @@ +{ + "extends": "@ljharb/tsconfig", + "compilerOptions": { + "target": "es2021", + }, + "exclude": [ + "coverage", + ], +} diff --git a/tools/ui/node_modules/graceful-fs/LICENSE b/tools/ui/node_modules/graceful-fs/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..e906a25acfb5ee2f955bd39101a207e3458463bd --- /dev/null +++ b/tools/ui/node_modules/graceful-fs/LICENSE @@ -0,0 +1,15 @@ +The ISC License + +Copyright (c) 2011-2022 Isaac Z. Schlueter, Ben Noordhuis, and Contributors + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR +IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff --git a/tools/ui/node_modules/graceful-fs/README.md b/tools/ui/node_modules/graceful-fs/README.md new file mode 100644 index 0000000000000000000000000000000000000000..82d6e4daf0cdb8543cca8ce644e6b6dfa61b86f8 --- /dev/null +++ b/tools/ui/node_modules/graceful-fs/README.md @@ -0,0 +1,143 @@ +# graceful-fs + +graceful-fs functions as a drop-in replacement for the fs module, +making various improvements. + +The improvements are meant to normalize behavior across different +platforms and environments, and to make filesystem access more +resilient to errors. + +## Improvements over [fs module](https://nodejs.org/api/fs.html) + +* Queues up `open` and `readdir` calls, and retries them once + something closes if there is an EMFILE error from too many file + descriptors. +* fixes `lchmod` for Node versions prior to 0.6.2. +* implements `fs.lutimes` if possible. Otherwise it becomes a noop. +* ignores `EINVAL` and `EPERM` errors in `chown`, `fchown` or + `lchown` if the user isn't root. +* makes `lchmod` and `lchown` become noops, if not available. +* retries reading a file if `read` results in EAGAIN error. + +On Windows, it retries renaming a file for up to one second if `EACCESS` +or `EPERM` error occurs, likely because antivirus software has locked +the directory. + +## USAGE + +```javascript +// use just like fs +var fs = require('graceful-fs') + +// now go and do stuff with it... +fs.readFile('some-file-or-whatever', (err, data) => { + // Do stuff here. +}) +``` + +## Sync methods + +This module cannot intercept or handle `EMFILE` or `ENFILE` errors from sync +methods. If you use sync methods which open file descriptors then you are +responsible for dealing with any errors. + +This is a known limitation, not a bug. + +## Global Patching + +If you want to patch the global fs module (or any other fs-like +module) you can do this: + +```javascript +// Make sure to read the caveat below. +var realFs = require('fs') +var gracefulFs = require('graceful-fs') +gracefulFs.gracefulify(realFs) +``` + +This should only ever be done at the top-level application layer, in +order to delay on EMFILE errors from any fs-using dependencies. You +should **not** do this in a library, because it can cause unexpected +delays in other parts of the program. + +## Changes + +This module is fairly stable at this point, and used by a lot of +things. That being said, because it implements a subtle behavior +change in a core part of the node API, even modest changes can be +extremely breaking, and the versioning is thus biased towards +bumping the major when in doubt. + +The main change between major versions has been switching between +providing a fully-patched `fs` module vs monkey-patching the node core +builtin, and the approach by which a non-monkey-patched `fs` was +created. + +The goal is to trade `EMFILE` errors for slower fs operations. So, if +you try to open a zillion files, rather than crashing, `open` +operations will be queued up and wait for something else to `close`. + +There are advantages to each approach. Monkey-patching the fs means +that no `EMFILE` errors can possibly occur anywhere in your +application, because everything is using the same core `fs` module, +which is patched. However, it can also obviously cause undesirable +side-effects, especially if the module is loaded multiple times. + +Implementing a separate-but-identical patched `fs` module is more +surgical (and doesn't run the risk of patching multiple times), but +also imposes the challenge of keeping in sync with the core module. + +The current approach loads the `fs` module, and then creates a +lookalike object that has all the same methods, except a few that are +patched. It is safe to use in all versions of Node from 0.8 through +7.0. + +### v4 + +* Do not monkey-patch the fs module. This module may now be used as a + drop-in dep, and users can opt into monkey-patching the fs builtin + if their app requires it. + +### v3 + +* Monkey-patch fs, because the eval approach no longer works on recent + node. +* fixed possible type-error throw if rename fails on windows +* verify that we *never* get EMFILE errors +* Ignore ENOSYS from chmod/chown +* clarify that graceful-fs must be used as a drop-in + +### v2.1.0 + +* Use eval rather than monkey-patching fs. +* readdir: Always sort the results +* win32: requeue a file if error has an OK status + +### v2.0 + +* A return to monkey patching +* wrap process.cwd + +### v1.1 + +* wrap readFile +* Wrap fs.writeFile. +* readdir protection +* Don't clobber the fs builtin +* Handle fs.read EAGAIN errors by trying again +* Expose the curOpen counter +* No-op lchown/lchmod if not implemented +* fs.rename patch only for win32 +* Patch fs.rename to handle AV software on Windows +* Close #4 Chown should not fail on einval or eperm if non-root +* Fix isaacs/fstream#1 Only wrap fs one time +* Fix #3 Start at 1024 max files, then back off on EMFILE +* lutimes that doens't blow up on Linux +* A full on-rewrite using a queue instead of just swallowing the EMFILE error +* Wrap Read/Write streams as well + +### 1.0 + +* Update engines for node 0.6 +* Be lstat-graceful on Windows +* first diff --git a/tools/ui/node_modules/graceful-fs/clone.js b/tools/ui/node_modules/graceful-fs/clone.js new file mode 100644 index 0000000000000000000000000000000000000000..dff3cc8c504b4cf14054b5d7bbc64b1696bc9fec --- /dev/null +++ b/tools/ui/node_modules/graceful-fs/clone.js @@ -0,0 +1,23 @@ +'use strict' + +module.exports = clone + +var getPrototypeOf = Object.getPrototypeOf || function (obj) { + return obj.__proto__ +} + +function clone (obj) { + if (obj === null || typeof obj !== 'object') + return obj + + if (obj instanceof Object) + var copy = { __proto__: getPrototypeOf(obj) } + else + var copy = Object.create(null) + + Object.getOwnPropertyNames(obj).forEach(function (key) { + Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key)) + }) + + return copy +} diff --git a/tools/ui/node_modules/graceful-fs/graceful-fs.js b/tools/ui/node_modules/graceful-fs/graceful-fs.js new file mode 100644 index 0000000000000000000000000000000000000000..8d5b89e4fa7fdbaebf58556cc044d2a912bce5de --- /dev/null +++ b/tools/ui/node_modules/graceful-fs/graceful-fs.js @@ -0,0 +1,448 @@ +var fs = require('fs') +var polyfills = require('./polyfills.js') +var legacy = require('./legacy-streams.js') +var clone = require('./clone.js') + +var util = require('util') + +/* istanbul ignore next - node 0.x polyfill */ +var gracefulQueue +var previousSymbol + +/* istanbul ignore else - node 0.x polyfill */ +if (typeof Symbol === 'function' && typeof Symbol.for === 'function') { + gracefulQueue = Symbol.for('graceful-fs.queue') + // This is used in testing by future versions + previousSymbol = Symbol.for('graceful-fs.previous') +} else { + gracefulQueue = '___graceful-fs.queue' + previousSymbol = '___graceful-fs.previous' +} + +function noop () {} + +function publishQueue(context, queue) { + Object.defineProperty(context, gracefulQueue, { + get: function() { + return queue + } + }) +} + +var debug = noop +if (util.debuglog) + debug = util.debuglog('gfs4') +else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) + debug = function() { + var m = util.format.apply(util, arguments) + m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ') + console.error(m) + } + +// Once time initialization +if (!fs[gracefulQueue]) { + // This queue can be shared by multiple loaded instances + var queue = global[gracefulQueue] || [] + publishQueue(fs, queue) + + // Patch fs.close/closeSync to shared queue version, because we need + // to retry() whenever a close happens *anywhere* in the program. + // This is essential when multiple graceful-fs instances are + // in play at the same time. + fs.close = (function (fs$close) { + function close (fd, cb) { + return fs$close.call(fs, fd, function (err) { + // This function uses the graceful-fs shared queue + if (!err) { + resetQueue() + } + + if (typeof cb === 'function') + cb.apply(this, arguments) + }) + } + + Object.defineProperty(close, previousSymbol, { + value: fs$close + }) + return close + })(fs.close) + + fs.closeSync = (function (fs$closeSync) { + function closeSync (fd) { + // This function uses the graceful-fs shared queue + fs$closeSync.apply(fs, arguments) + resetQueue() + } + + Object.defineProperty(closeSync, previousSymbol, { + value: fs$closeSync + }) + return closeSync + })(fs.closeSync) + + if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) { + process.on('exit', function() { + debug(fs[gracefulQueue]) + require('assert').equal(fs[gracefulQueue].length, 0) + }) + } +} + +if (!global[gracefulQueue]) { + publishQueue(global, fs[gracefulQueue]); +} + +module.exports = patch(clone(fs)) +if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) { + module.exports = patch(fs) + fs.__patched = true; +} + +function patch (fs) { + // Everything that references the open() function needs to be in here + polyfills(fs) + fs.gracefulify = patch + + fs.createReadStream = createReadStream + fs.createWriteStream = createWriteStream + var fs$readFile = fs.readFile + fs.readFile = readFile + function readFile (path, options, cb) { + if (typeof options === 'function') + cb = options, options = null + + return go$readFile(path, options, cb) + + function go$readFile (path, options, cb, startTime) { + return fs$readFile(path, options, function (err) { + if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) + enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()]) + else { + if (typeof cb === 'function') + cb.apply(this, arguments) + } + }) + } + } + + var fs$writeFile = fs.writeFile + fs.writeFile = writeFile + function writeFile (path, data, options, cb) { + if (typeof options === 'function') + cb = options, options = null + + return go$writeFile(path, data, options, cb) + + function go$writeFile (path, data, options, cb, startTime) { + return fs$writeFile(path, data, options, function (err) { + if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) + enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]) + else { + if (typeof cb === 'function') + cb.apply(this, arguments) + } + }) + } + } + + var fs$appendFile = fs.appendFile + if (fs$appendFile) + fs.appendFile = appendFile + function appendFile (path, data, options, cb) { + if (typeof options === 'function') + cb = options, options = null + + return go$appendFile(path, data, options, cb) + + function go$appendFile (path, data, options, cb, startTime) { + return fs$appendFile(path, data, options, function (err) { + if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) + enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()]) + else { + if (typeof cb === 'function') + cb.apply(this, arguments) + } + }) + } + } + + var fs$copyFile = fs.copyFile + if (fs$copyFile) + fs.copyFile = copyFile + function copyFile (src, dest, flags, cb) { + if (typeof flags === 'function') { + cb = flags + flags = 0 + } + return go$copyFile(src, dest, flags, cb) + + function go$copyFile (src, dest, flags, cb, startTime) { + return fs$copyFile(src, dest, flags, function (err) { + if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) + enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()]) + else { + if (typeof cb === 'function') + cb.apply(this, arguments) + } + }) + } + } + + var fs$readdir = fs.readdir + fs.readdir = readdir + var noReaddirOptionVersions = /^v[0-5]\./ + function readdir (path, options, cb) { + if (typeof options === 'function') + cb = options, options = null + + var go$readdir = noReaddirOptionVersions.test(process.version) + ? function go$readdir (path, options, cb, startTime) { + return fs$readdir(path, fs$readdirCallback( + path, options, cb, startTime + )) + } + : function go$readdir (path, options, cb, startTime) { + return fs$readdir(path, options, fs$readdirCallback( + path, options, cb, startTime + )) + } + + return go$readdir(path, options, cb) + + function fs$readdirCallback (path, options, cb, startTime) { + return function (err, files) { + if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) + enqueue([ + go$readdir, + [path, options, cb], + err, + startTime || Date.now(), + Date.now() + ]) + else { + if (files && files.sort) + files.sort() + + if (typeof cb === 'function') + cb.call(this, err, files) + } + } + } + } + + if (process.version.substr(0, 4) === 'v0.8') { + var legStreams = legacy(fs) + ReadStream = legStreams.ReadStream + WriteStream = legStreams.WriteStream + } + + var fs$ReadStream = fs.ReadStream + if (fs$ReadStream) { + ReadStream.prototype = Object.create(fs$ReadStream.prototype) + ReadStream.prototype.open = ReadStream$open + } + + var fs$WriteStream = fs.WriteStream + if (fs$WriteStream) { + WriteStream.prototype = Object.create(fs$WriteStream.prototype) + WriteStream.prototype.open = WriteStream$open + } + + Object.defineProperty(fs, 'ReadStream', { + get: function () { + return ReadStream + }, + set: function (val) { + ReadStream = val + }, + enumerable: true, + configurable: true + }) + Object.defineProperty(fs, 'WriteStream', { + get: function () { + return WriteStream + }, + set: function (val) { + WriteStream = val + }, + enumerable: true, + configurable: true + }) + + // legacy names + var FileReadStream = ReadStream + Object.defineProperty(fs, 'FileReadStream', { + get: function () { + return FileReadStream + }, + set: function (val) { + FileReadStream = val + }, + enumerable: true, + configurable: true + }) + var FileWriteStream = WriteStream + Object.defineProperty(fs, 'FileWriteStream', { + get: function () { + return FileWriteStream + }, + set: function (val) { + FileWriteStream = val + }, + enumerable: true, + configurable: true + }) + + function ReadStream (path, options) { + if (this instanceof ReadStream) + return fs$ReadStream.apply(this, arguments), this + else + return ReadStream.apply(Object.create(ReadStream.prototype), arguments) + } + + function ReadStream$open () { + var that = this + open(that.path, that.flags, that.mode, function (err, fd) { + if (err) { + if (that.autoClose) + that.destroy() + + that.emit('error', err) + } else { + that.fd = fd + that.emit('open', fd) + that.read() + } + }) + } + + function WriteStream (path, options) { + if (this instanceof WriteStream) + return fs$WriteStream.apply(this, arguments), this + else + return WriteStream.apply(Object.create(WriteStream.prototype), arguments) + } + + function WriteStream$open () { + var that = this + open(that.path, that.flags, that.mode, function (err, fd) { + if (err) { + that.destroy() + that.emit('error', err) + } else { + that.fd = fd + that.emit('open', fd) + } + }) + } + + function createReadStream (path, options) { + return new fs.ReadStream(path, options) + } + + function createWriteStream (path, options) { + return new fs.WriteStream(path, options) + } + + var fs$open = fs.open + fs.open = open + function open (path, flags, mode, cb) { + if (typeof mode === 'function') + cb = mode, mode = null + + return go$open(path, flags, mode, cb) + + function go$open (path, flags, mode, cb, startTime) { + return fs$open(path, flags, mode, function (err, fd) { + if (err && (err.code === 'EMFILE' || err.code === 'ENFILE')) + enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()]) + else { + if (typeof cb === 'function') + cb.apply(this, arguments) + } + }) + } + } + + return fs +} + +function enqueue (elem) { + debug('ENQUEUE', elem[0].name, elem[1]) + fs[gracefulQueue].push(elem) + retry() +} + +// keep track of the timeout between retry() calls +var retryTimer + +// reset the startTime and lastTime to now +// this resets the start of the 60 second overall timeout as well as the +// delay between attempts so that we'll retry these jobs sooner +function resetQueue () { + var now = Date.now() + for (var i = 0; i < fs[gracefulQueue].length; ++i) { + // entries that are only a length of 2 are from an older version, don't + // bother modifying those since they'll be retried anyway. + if (fs[gracefulQueue][i].length > 2) { + fs[gracefulQueue][i][3] = now // startTime + fs[gracefulQueue][i][4] = now // lastTime + } + } + // call retry to make sure we're actively processing the queue + retry() +} + +function retry () { + // clear the timer and remove it to help prevent unintended concurrency + clearTimeout(retryTimer) + retryTimer = undefined + + if (fs[gracefulQueue].length === 0) + return + + var elem = fs[gracefulQueue].shift() + var fn = elem[0] + var args = elem[1] + // these items may be unset if they were added by an older graceful-fs + var err = elem[2] + var startTime = elem[3] + var lastTime = elem[4] + + // if we don't have a startTime we have no way of knowing if we've waited + // long enough, so go ahead and retry this item now + if (startTime === undefined) { + debug('RETRY', fn.name, args) + fn.apply(null, args) + } else if (Date.now() - startTime >= 60000) { + // it's been more than 60 seconds total, bail now + debug('TIMEOUT', fn.name, args) + var cb = args.pop() + if (typeof cb === 'function') + cb.call(null, err) + } else { + // the amount of time between the last attempt and right now + var sinceAttempt = Date.now() - lastTime + // the amount of time between when we first tried, and when we last tried + // rounded up to at least 1 + var sinceStart = Math.max(lastTime - startTime, 1) + // backoff. wait longer than the total time we've been retrying, but only + // up to a maximum of 100ms + var desiredDelay = Math.min(sinceStart * 1.2, 100) + // it's been long enough since the last retry, do it again + if (sinceAttempt >= desiredDelay) { + debug('RETRY', fn.name, args) + fn.apply(null, args.concat([startTime])) + } else { + // if we can't do this job yet, push it to the end of the queue + // and let the next iteration check again + fs[gracefulQueue].push(elem) + } + } + + // schedule our next run if one isn't already scheduled + if (retryTimer === undefined) { + retryTimer = setTimeout(retry, 0) + } +} diff --git a/tools/ui/node_modules/graceful-fs/legacy-streams.js b/tools/ui/node_modules/graceful-fs/legacy-streams.js new file mode 100644 index 0000000000000000000000000000000000000000..d617b50fc0832dcce4ba05f7a7200938438ead90 --- /dev/null +++ b/tools/ui/node_modules/graceful-fs/legacy-streams.js @@ -0,0 +1,118 @@ +var Stream = require('stream').Stream + +module.exports = legacy + +function legacy (fs) { + return { + ReadStream: ReadStream, + WriteStream: WriteStream + } + + function ReadStream (path, options) { + if (!(this instanceof ReadStream)) return new ReadStream(path, options); + + Stream.call(this); + + var self = this; + + this.path = path; + this.fd = null; + this.readable = true; + this.paused = false; + + this.flags = 'r'; + this.mode = 438; /*=0666*/ + this.bufferSize = 64 * 1024; + + options = options || {}; + + // Mixin options into this + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; + } + + if (this.encoding) this.setEncoding(this.encoding); + + if (this.start !== undefined) { + if ('number' !== typeof this.start) { + throw TypeError('start must be a Number'); + } + if (this.end === undefined) { + this.end = Infinity; + } else if ('number' !== typeof this.end) { + throw TypeError('end must be a Number'); + } + + if (this.start > this.end) { + throw new Error('start must be <= end'); + } + + this.pos = this.start; + } + + if (this.fd !== null) { + process.nextTick(function() { + self._read(); + }); + return; + } + + fs.open(this.path, this.flags, this.mode, function (err, fd) { + if (err) { + self.emit('error', err); + self.readable = false; + return; + } + + self.fd = fd; + self.emit('open', fd); + self._read(); + }) + } + + function WriteStream (path, options) { + if (!(this instanceof WriteStream)) return new WriteStream(path, options); + + Stream.call(this); + + this.path = path; + this.fd = null; + this.writable = true; + + this.flags = 'w'; + this.encoding = 'binary'; + this.mode = 438; /*=0666*/ + this.bytesWritten = 0; + + options = options || {}; + + // Mixin options into this + var keys = Object.keys(options); + for (var index = 0, length = keys.length; index < length; index++) { + var key = keys[index]; + this[key] = options[key]; + } + + if (this.start !== undefined) { + if ('number' !== typeof this.start) { + throw TypeError('start must be a Number'); + } + if (this.start < 0) { + throw new Error('start must be >= zero'); + } + + this.pos = this.start; + } + + this.busy = false; + this._queue = []; + + if (this.fd === null) { + this._open = fs.open; + this._queue.push([this._open, this.path, this.flags, this.mode, undefined]); + this.flush(); + } + } +} diff --git a/tools/ui/node_modules/graceful-fs/package.json b/tools/ui/node_modules/graceful-fs/package.json new file mode 100644 index 0000000000000000000000000000000000000000..87babf0248563c1767d58126c403954bf3e9e024 --- /dev/null +++ b/tools/ui/node_modules/graceful-fs/package.json @@ -0,0 +1,53 @@ +{ + "name": "graceful-fs", + "description": "A drop-in replacement for fs, making various improvements.", + "version": "4.2.11", + "repository": { + "type": "git", + "url": "https://github.com/isaacs/node-graceful-fs" + }, + "main": "graceful-fs.js", + "directories": { + "test": "test" + }, + "scripts": { + "preversion": "npm test", + "postversion": "npm publish", + "postpublish": "git push origin --follow-tags", + "test": "nyc --silent node test.js | tap -c -", + "posttest": "nyc report" + }, + "keywords": [ + "fs", + "module", + "reading", + "retry", + "retries", + "queue", + "error", + "errors", + "handling", + "EMFILE", + "EAGAIN", + "EINVAL", + "EPERM", + "EACCESS" + ], + "license": "ISC", + "devDependencies": { + "import-fresh": "^2.0.0", + "mkdirp": "^0.5.0", + "rimraf": "^2.2.8", + "tap": "^16.3.4" + }, + "files": [ + "fs.js", + "graceful-fs.js", + "legacy-streams.js", + "polyfills.js", + "clone.js" + ], + "tap": { + "reporter": "classic" + } +} diff --git a/tools/ui/node_modules/graceful-fs/polyfills.js b/tools/ui/node_modules/graceful-fs/polyfills.js new file mode 100644 index 0000000000000000000000000000000000000000..453f1a9e702d1aaf9a34cb8460f30073dc83bcf5 --- /dev/null +++ b/tools/ui/node_modules/graceful-fs/polyfills.js @@ -0,0 +1,355 @@ +var constants = require('constants') + +var origCwd = process.cwd +var cwd = null + +var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform + +process.cwd = function() { + if (!cwd) + cwd = origCwd.call(process) + return cwd +} +try { + process.cwd() +} catch (er) {} + +// This check is needed until node.js 12 is required +if (typeof process.chdir === 'function') { + var chdir = process.chdir + process.chdir = function (d) { + cwd = null + chdir.call(process, d) + } + if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir) +} + +module.exports = patch + +function patch (fs) { + // (re-)implement some things that are known busted or missing. + + // lchmod, broken prior to 0.6.2 + // back-port the fix here. + if (constants.hasOwnProperty('O_SYMLINK') && + process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) { + patchLchmod(fs) + } + + // lutimes implementation, or no-op + if (!fs.lutimes) { + patchLutimes(fs) + } + + // https://github.com/isaacs/node-graceful-fs/issues/4 + // Chown should not fail on einval or eperm if non-root. + // It should not fail on enosys ever, as this just indicates + // that a fs doesn't support the intended operation. + + fs.chown = chownFix(fs.chown) + fs.fchown = chownFix(fs.fchown) + fs.lchown = chownFix(fs.lchown) + + fs.chmod = chmodFix(fs.chmod) + fs.fchmod = chmodFix(fs.fchmod) + fs.lchmod = chmodFix(fs.lchmod) + + fs.chownSync = chownFixSync(fs.chownSync) + fs.fchownSync = chownFixSync(fs.fchownSync) + fs.lchownSync = chownFixSync(fs.lchownSync) + + fs.chmodSync = chmodFixSync(fs.chmodSync) + fs.fchmodSync = chmodFixSync(fs.fchmodSync) + fs.lchmodSync = chmodFixSync(fs.lchmodSync) + + fs.stat = statFix(fs.stat) + fs.fstat = statFix(fs.fstat) + fs.lstat = statFix(fs.lstat) + + fs.statSync = statFixSync(fs.statSync) + fs.fstatSync = statFixSync(fs.fstatSync) + fs.lstatSync = statFixSync(fs.lstatSync) + + // if lchmod/lchown do not exist, then make them no-ops + if (fs.chmod && !fs.lchmod) { + fs.lchmod = function (path, mode, cb) { + if (cb) process.nextTick(cb) + } + fs.lchmodSync = function () {} + } + if (fs.chown && !fs.lchown) { + fs.lchown = function (path, uid, gid, cb) { + if (cb) process.nextTick(cb) + } + fs.lchownSync = function () {} + } + + // on Windows, A/V software can lock the directory, causing this + // to fail with an EACCES or EPERM if the directory contains newly + // created files. Try again on failure, for up to 60 seconds. + + // Set the timeout this long because some Windows Anti-Virus, such as Parity + // bit9, may lock files for up to a minute, causing npm package install + // failures. Also, take care to yield the scheduler. Windows scheduling gives + // CPU to a busy looping process, which can cause the program causing the lock + // contention to be starved of CPU by node, so the contention doesn't resolve. + if (platform === "win32") { + fs.rename = typeof fs.rename !== 'function' ? fs.rename + : (function (fs$rename) { + function rename (from, to, cb) { + var start = Date.now() + var backoff = 0; + fs$rename(from, to, function CB (er) { + if (er + && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") + && Date.now() - start < 60000) { + setTimeout(function() { + fs.stat(to, function (stater, st) { + if (stater && stater.code === "ENOENT") + fs$rename(from, to, CB); + else + cb(er) + }) + }, backoff) + if (backoff < 100) + backoff += 10; + return; + } + if (cb) cb(er) + }) + } + if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename) + return rename + })(fs.rename) + } + + // if read() returns EAGAIN, then just try it again. + fs.read = typeof fs.read !== 'function' ? fs.read + : (function (fs$read) { + function read (fd, buffer, offset, length, position, callback_) { + var callback + if (callback_ && typeof callback_ === 'function') { + var eagCounter = 0 + callback = function (er, _, __) { + if (er && er.code === 'EAGAIN' && eagCounter < 10) { + eagCounter ++ + return fs$read.call(fs, fd, buffer, offset, length, position, callback) + } + callback_.apply(this, arguments) + } + } + return fs$read.call(fs, fd, buffer, offset, length, position, callback) + } + + // This ensures `util.promisify` works as it does for native `fs.read`. + if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read) + return read + })(fs.read) + + fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync + : (function (fs$readSync) { return function (fd, buffer, offset, length, position) { + var eagCounter = 0 + while (true) { + try { + return fs$readSync.call(fs, fd, buffer, offset, length, position) + } catch (er) { + if (er.code === 'EAGAIN' && eagCounter < 10) { + eagCounter ++ + continue + } + throw er + } + } + }})(fs.readSync) + + function patchLchmod (fs) { + fs.lchmod = function (path, mode, callback) { + fs.open( path + , constants.O_WRONLY | constants.O_SYMLINK + , mode + , function (err, fd) { + if (err) { + if (callback) callback(err) + return + } + // prefer to return the chmod error, if one occurs, + // but still try to close, and report closing errors if they occur. + fs.fchmod(fd, mode, function (err) { + fs.close(fd, function(err2) { + if (callback) callback(err || err2) + }) + }) + }) + } + + fs.lchmodSync = function (path, mode) { + var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode) + + // prefer to return the chmod error, if one occurs, + // but still try to close, and report closing errors if they occur. + var threw = true + var ret + try { + ret = fs.fchmodSync(fd, mode) + threw = false + } finally { + if (threw) { + try { + fs.closeSync(fd) + } catch (er) {} + } else { + fs.closeSync(fd) + } + } + return ret + } + } + + function patchLutimes (fs) { + if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) { + fs.lutimes = function (path, at, mt, cb) { + fs.open(path, constants.O_SYMLINK, function (er, fd) { + if (er) { + if (cb) cb(er) + return + } + fs.futimes(fd, at, mt, function (er) { + fs.close(fd, function (er2) { + if (cb) cb(er || er2) + }) + }) + }) + } + + fs.lutimesSync = function (path, at, mt) { + var fd = fs.openSync(path, constants.O_SYMLINK) + var ret + var threw = true + try { + ret = fs.futimesSync(fd, at, mt) + threw = false + } finally { + if (threw) { + try { + fs.closeSync(fd) + } catch (er) {} + } else { + fs.closeSync(fd) + } + } + return ret + } + + } else if (fs.futimes) { + fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) } + fs.lutimesSync = function () {} + } + } + + function chmodFix (orig) { + if (!orig) return orig + return function (target, mode, cb) { + return orig.call(fs, target, mode, function (er) { + if (chownErOk(er)) er = null + if (cb) cb.apply(this, arguments) + }) + } + } + + function chmodFixSync (orig) { + if (!orig) return orig + return function (target, mode) { + try { + return orig.call(fs, target, mode) + } catch (er) { + if (!chownErOk(er)) throw er + } + } + } + + + function chownFix (orig) { + if (!orig) return orig + return function (target, uid, gid, cb) { + return orig.call(fs, target, uid, gid, function (er) { + if (chownErOk(er)) er = null + if (cb) cb.apply(this, arguments) + }) + } + } + + function chownFixSync (orig) { + if (!orig) return orig + return function (target, uid, gid) { + try { + return orig.call(fs, target, uid, gid) + } catch (er) { + if (!chownErOk(er)) throw er + } + } + } + + function statFix (orig) { + if (!orig) return orig + // Older versions of Node erroneously returned signed integers for + // uid + gid. + return function (target, options, cb) { + if (typeof options === 'function') { + cb = options + options = null + } + function callback (er, stats) { + if (stats) { + if (stats.uid < 0) stats.uid += 0x100000000 + if (stats.gid < 0) stats.gid += 0x100000000 + } + if (cb) cb.apply(this, arguments) + } + return options ? orig.call(fs, target, options, callback) + : orig.call(fs, target, callback) + } + } + + function statFixSync (orig) { + if (!orig) return orig + // Older versions of Node erroneously returned signed integers for + // uid + gid. + return function (target, options) { + var stats = options ? orig.call(fs, target, options) + : orig.call(fs, target) + if (stats) { + if (stats.uid < 0) stats.uid += 0x100000000 + if (stats.gid < 0) stats.gid += 0x100000000 + } + return stats; + } + } + + // ENOSYS means that the fs doesn't support the op. Just ignore + // that, because it doesn't matter. + // + // if there's no getuid, or if getuid() is something other + // than 0, and the error is EINVAL or EPERM, then just ignore + // it. + // + // This specific case is a silent failure in cp, install, tar, + // and most other unix tools that manage permissions. + // + // When running as root, or if other types of errors are + // encountered, then it's strict. + function chownErOk (er) { + if (!er) + return true + + if (er.code === "ENOSYS") + return true + + var nonroot = !process.getuid || process.getuid() !== 0 + if (nonroot) { + if (er.code === "EINVAL" || er.code === "EPERM") + return true + } + + return false + } +} diff --git a/tools/ui/node_modules/hachure-fill/LICENSE b/tools/ui/node_modules/hachure-fill/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..b09f840d3e475ab6b4a5c1b8990f121336fe7fec --- /dev/null +++ b/tools/ui/node_modules/hachure-fill/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2023 Preet Shihn + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/hachure-fill/README.md b/tools/ui/node_modules/hachure-fill/README.md new file mode 100644 index 0000000000000000000000000000000000000000..2f5174a57b3337d5dac8655286e55e349885cc82 --- /dev/null +++ b/tools/ui/node_modules/hachure-fill/README.md @@ -0,0 +1,57 @@ +# hachure-fill + +[Demo](https://hachure-fill.pages.dev/) + +This package calculates the hachure lined to fill a polygon. The **angle** of the lines and the **gap** between lines can be configured. + +The algorithm works on convex, concave, simple, complex polygons, and polygons with holes. + +![preview of a polygon](https://user-images.githubusercontent.com/833927/242424090-90e60c00-c87b-4033-ae63-c0f38fa5d291.png) + + +## Install + +From npm + +``` +npm install --save hachure-fill +``` + +The package is distributed as an ES6 module. + +## Usage + +### hachureFill(points: Point[], angle: number, gap: number): Line[]; + +The function takes in a polygon, which is represented as an array of points (each point being a an array of 2 numbers `[x, y]`). + +The **angle** sets the angle of the hachure lines in degrees. + +The **gap** arguments sets the distance between each hachure line. + +The function returns an array of lines. Each line is an array of two points. + +```javascript +import { hachureFill } from 'hachure-fill'; + +// Polygon vertices +const vertices = [ + [10, 10], + [200, 10], + [100, 100], + [300, 100], + [60, 200] +]; + +// Lines filling the polygon +// at an angle of 45 degrees. +// Lines are 10px apart. +const lines = hachureFill(vertices, 45, 10); + +// Draw lines... +``` + +### hachureFill(points: Point[][], angle: number, gap: number): Line[]; + +When dealing with Polygon with holes, you can provide an array of polygons. The outer polygon, and polygones represented each of the holes. +The polygons need not be nested, but if they are, even-odd rules apply to fill the shape. diff --git a/tools/ui/node_modules/hachure-fill/bin/hachure.d.ts b/tools/ui/node_modules/hachure-fill/bin/hachure.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..23f2f483d82eb774dbb8c8aac946820f4829ba8a --- /dev/null +++ b/tools/ui/node_modules/hachure-fill/bin/hachure.d.ts @@ -0,0 +1,4 @@ +export type Point = [number, number]; +export type Line = [Point, Point]; +export type Polygon = Point[]; +export declare function hachureLines(polygons: Polygon | Polygon[], hachureGap: number, hachureAngle: number, hachureStepOffset?: number): Line[]; diff --git a/tools/ui/node_modules/hachure-fill/bin/hachure.js b/tools/ui/node_modules/hachure-fill/bin/hachure.js new file mode 100644 index 0000000000000000000000000000000000000000..cf2fd36cbee2c1ee792e294ea9baac81482a9919 --- /dev/null +++ b/tools/ui/node_modules/hachure-fill/bin/hachure.js @@ -0,0 +1,146 @@ +function rotatePoints(points, center, degrees) { + if (points && points.length) { + const [cx, cy] = center; + const angle = (Math.PI / 180) * degrees; + const cos = Math.cos(angle); + const sin = Math.sin(angle); + for (const p of points) { + const [x, y] = p; + p[0] = ((x - cx) * cos) - ((y - cy) * sin) + cx; + p[1] = ((x - cx) * sin) + ((y - cy) * cos) + cy; + } + } +} +function rotateLines(lines, center, degrees) { + const points = []; + lines.forEach((line) => points.push(...line)); + rotatePoints(points, center, degrees); +} +function areSamePoints(p1, p2) { + return p1[0] === p2[0] && p1[1] === p2[1]; +} +export function hachureLines(polygons, hachureGap, hachureAngle, hachureStepOffset = 1) { + const angle = hachureAngle; + const gap = Math.max(hachureGap, 0.1); + const polygonList = (polygons[0] && polygons[0][0] && (typeof polygons[0][0] === 'number')) ? [polygons] : polygons; + const rotationCenter = [0, 0]; + if (angle) { + for (const polygon of polygonList) { + rotatePoints(polygon, rotationCenter, angle); + } + } + const lines = straightHachureLines(polygonList, gap, hachureStepOffset); + if (angle) { + for (const polygon of polygonList) { + rotatePoints(polygon, rotationCenter, -angle); + } + rotateLines(lines, rotationCenter, -angle); + } + return lines; +} +function straightHachureLines(polygons, gap, hachureStepOffset) { + const vertexArray = []; + for (const polygon of polygons) { + const vertices = [...polygon]; + if (!areSamePoints(vertices[0], vertices[vertices.length - 1])) { + vertices.push([vertices[0][0], vertices[0][1]]); + } + if (vertices.length > 2) { + vertexArray.push(vertices); + } + } + const lines = []; + gap = Math.max(gap, 0.1); + // Create sorted edges table + const edges = []; + for (const vertices of vertexArray) { + for (let i = 0; i < vertices.length - 1; i++) { + const p1 = vertices[i]; + const p2 = vertices[i + 1]; + if (p1[1] !== p2[1]) { + const ymin = Math.min(p1[1], p2[1]); + edges.push({ + ymin, + ymax: Math.max(p1[1], p2[1]), + x: ymin === p1[1] ? p1[0] : p2[0], + islope: (p2[0] - p1[0]) / (p2[1] - p1[1]), + }); + } + } + } + edges.sort((e1, e2) => { + if (e1.ymin < e2.ymin) { + return -1; + } + if (e1.ymin > e2.ymin) { + return 1; + } + if (e1.x < e2.x) { + return -1; + } + if (e1.x > e2.x) { + return 1; + } + if (e1.ymax === e2.ymax) { + return 0; + } + return (e1.ymax - e2.ymax) / Math.abs((e1.ymax - e2.ymax)); + }); + if (!edges.length) { + return lines; + } + // Start scanning + let activeEdges = []; + let y = edges[0].ymin; + let iteration = 0; + while (activeEdges.length || edges.length) { + if (edges.length) { + let ix = -1; + for (let i = 0; i < edges.length; i++) { + if (edges[i].ymin > y) { + break; + } + ix = i; + } + const removed = edges.splice(0, ix + 1); + removed.forEach((edge) => { + activeEdges.push({ s: y, edge }); + }); + } + activeEdges = activeEdges.filter((ae) => { + if (ae.edge.ymax <= y) { + return false; + } + return true; + }); + activeEdges.sort((ae1, ae2) => { + if (ae1.edge.x === ae2.edge.x) { + return 0; + } + return (ae1.edge.x - ae2.edge.x) / Math.abs((ae1.edge.x - ae2.edge.x)); + }); + // fill between the edges + if ((hachureStepOffset !== 1) || (iteration % gap === 0)) { + if (activeEdges.length > 1) { + for (let i = 0; i < activeEdges.length; i = i + 2) { + const nexti = i + 1; + if (nexti >= activeEdges.length) { + break; + } + const ce = activeEdges[i].edge; + const ne = activeEdges[nexti].edge; + lines.push([ + [Math.round(ce.x), y], + [Math.round(ne.x), y], + ]); + } + } + } + y += hachureStepOffset; + activeEdges.forEach((ae) => { + ae.edge.x = ae.edge.x + (hachureStepOffset * ae.edge.islope); + }); + iteration++; + } + return lines; +} diff --git a/tools/ui/node_modules/hachure-fill/index.d.ts b/tools/ui/node_modules/hachure-fill/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..374a4c48eb2565f2caa85bc93d07e600fc02de7d --- /dev/null +++ b/tools/ui/node_modules/hachure-fill/index.d.ts @@ -0,0 +1 @@ +export declare function hachureFill(points: [number, number][], angle?: number, gap?: number): [[number, number], [number, number]][]; \ No newline at end of file diff --git a/tools/ui/node_modules/hachure-fill/package.json b/tools/ui/node_modules/hachure-fill/package.json new file mode 100644 index 0000000000000000000000000000000000000000..c4741e6b1c5b40bcaedaf40f8be9c857fba2f868 --- /dev/null +++ b/tools/ui/node_modules/hachure-fill/package.json @@ -0,0 +1,36 @@ +{ + "name": "hachure-fill", + "version": "0.5.2", + "description": "Fill a polygon with lines ", + "main": "bin/hachure.js", + "types": "bin/hachure.d.ts", + "type": "module", + "scripts": { + "build": "npm run lint && npm run build-ts", + "build-ts": "rm -rf bin && tsc", + "lint": "eslint --ext ts src" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/pshihn/hachure-fill.git" + }, + "keywords": [ + "hachure", + "lines", + "polygon", + "plotter" + ], + "author": "Preet Shihn", + "license": "MIT", + "bugs": { + "url": "https://github.com/pshihn/hachure-fill/issues" + }, + "homepage": "https://github.com/pshihn/hachure-fill#readme", + "devDependencies": { + "@typescript-eslint/eslint-plugin": "^5.59.0", + "@typescript-eslint/parser": "^5.59.0", + "esbuild": "^0.17.18", + "eslint": "^8.39.0", + "typescript": "^5.0.4" + } +} \ No newline at end of file diff --git a/tools/ui/node_modules/has-bigints/.eslintrc b/tools/ui/node_modules/has-bigints/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..3b5d9e90ec405f85dd7f9066656efccc51193697 --- /dev/null +++ b/tools/ui/node_modules/has-bigints/.eslintrc @@ -0,0 +1,5 @@ +{ + "root": true, + + "extends": "@ljharb", +} diff --git a/tools/ui/node_modules/has-bigints/.github/FUNDING.yml b/tools/ui/node_modules/has-bigints/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..5b597c8467722eb0ed4871da8789ad3235fd97dd --- /dev/null +++ b/tools/ui/node_modules/has-bigints/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/has-bigints +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/has-bigints/.nycrc b/tools/ui/node_modules/has-bigints/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..bdd626ce91477abbdd489b79988baebadbd3c897 --- /dev/null +++ b/tools/ui/node_modules/has-bigints/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/has-bigints/CHANGELOG.md b/tools/ui/node_modules/has-bigints/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..3d2051ee7372a77cca28278e23e951757381a035 --- /dev/null +++ b/tools/ui/node_modules/has-bigints/CHANGELOG.md @@ -0,0 +1,74 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.1.0](https://github.com/inspect-js/has-bigints/compare/v1.0.2...v1.1.0) - 2024-12-18 + +### Commits + +- [meta] use `npmignore` to autogenerate an npmignore file [`a411cea`](https://github.com/inspect-js/has-bigints/commit/a411ceaf68bc297944c1627ec914455843195398) +- [actions] split out node 10-20, and 20+ [`4515878`](https://github.com/inspect-js/has-bigints/commit/45158780f412a6362d7a6116c552f75e23b4be38) +- [New] add types [`c888241`](https://github.com/inspect-js/has-bigints/commit/c888241a4fda933a270369419d11ce7f19ea50ce) +- [actions] update rebase action to use reusable workflow [`6f44338`](https://github.com/inspect-js/has-bigints/commit/6f44338ebca614230de3c87dc82719cf067335a2) +- [Dev Deps] update `@ljharb/eslint-config`, `auto-changelog`, `npmignore`, `tape` [`ffa1e4d`](https://github.com/inspect-js/has-bigints/commit/ffa1e4daad689075fec091c86d6b53d4432b99ff) +- [Dev Deps] update `aud`, `tape` [`0f5d096`](https://github.com/inspect-js/has-bigints/commit/0f5d09697b37c182587313e4a9218353f8d3d22b) +- [meta] add missing `engines.node` [`3f73c71`](https://github.com/inspect-js/has-bigints/commit/3f73c71d7f4f13dfcec5520a51a97fb91645d9db) +- [Tests] replace `aud` with `npm audit` [`b007efd`](https://github.com/inspect-js/has-bigints/commit/b007efdd11608912a5dcae216748840a746d3517) +- [Dev Deps] add missing peer dep [`459c612`](https://github.com/inspect-js/has-bigints/commit/459c6126ecff63021664dbb48d19c6b1ddc2db14) + +## [v1.0.2](https://github.com/inspect-js/has-bigints/compare/v1.0.1...v1.0.2) - 2022-04-19 + +### Commits + +- [actions] reuse common workflows [`a655b7f`](https://github.com/inspect-js/has-bigints/commit/a655b7f7733ba2de078b3a59a704c2795440d08c) +- [actions] use `node/install` instead of `node/run`; use `codecov` action [`730a2e5`](https://github.com/inspect-js/has-bigints/commit/730a2e53d3f5f82ac43a11cb9753b11445d06d58) +- [readme] add github actions/codecov badges; update URLs [`9a83788`](https://github.com/inspect-js/has-bigints/commit/9a8378861917b41ebb360a9d8ab3d39aa33acf7b) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `safe-publish-latest`, `tape` [`b1edc52`](https://github.com/inspect-js/has-bigints/commit/b1edc522ef6c23556e55b9c81b65fe884d1e2cc4) +- [actions] update codecov uploader [`cbb1bd0`](https://github.com/inspect-js/has-bigints/commit/cbb1bd0eff486070a19283238da6afd33ca73b4b) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `tape` [`8717e6d`](https://github.com/inspect-js/has-bigints/commit/8717e6d6ae6b5010aea1fac5e48dfdfaf35d8c72) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `auto-changelog`, `safe-publish-latest`, `tape` [`5f70eab`](https://github.com/inspect-js/has-bigints/commit/5f70eab763118d40415f13e47446ea5c011fbe18) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`a1446bc`](https://github.com/inspect-js/has-bigints/commit/a1446bc3e806ce3911c73d6fbdd981f461c41019) +- [meta] use `prepublishOnly` script for npm 7+ [`f2dd197`](https://github.com/inspect-js/has-bigints/commit/f2dd19716a06ca7a971644761e864f0435db278e) +- [actions] use checkout v3 [`1ba72f1`](https://github.com/inspect-js/has-bigints/commit/1ba72f19ada076791ff193aca9d8537388d67ddb) +- [Refactor] use a global variable to get the original BigInt instead of a global property [`a7ccfac`](https://github.com/inspect-js/has-bigints/commit/a7ccfac0414e56dadd263fd07c0b5141388df502) +- [actions] skip `npm ls` on older nodes [`62d31e7`](https://github.com/inspect-js/has-bigints/commit/62d31e79658b16391458d0728e0dacbee8694ebb) + +## [v1.0.1](https://github.com/inspect-js/has-bigints/compare/v1.0.0...v1.0.1) - 2020-12-13 + +### Commits + +- [Tests] use shared travis-ci configs [`46a0d6b`](https://github.com/inspect-js/has-bigints/commit/46a0d6be7ed83bd7f5ead11e4eab7fc91570a448) +- [Tests] migrate tests to Github Actions [`91a38fa`](https://github.com/inspect-js/has-bigints/commit/91a38fa4b85a420b8cf4926b3799e6ceb60d8690) +- [meta] do not publish github action workflow files [`69aacba`](https://github.com/inspect-js/has-bigints/commit/69aacba320c1221e7fee1c71bde600bce063f24b) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `tape` [`64e2c08`](https://github.com/inspect-js/has-bigints/commit/64e2c0895b21ac91a137452fd2455932f62a2fc1) +- [Tests] run `nyc` on all tests; use `tape` runner [`8009375`](https://github.com/inspect-js/has-bigints/commit/8009375e5ec9faca6bbc09441002af5c5e59ff20) +- [actions] add automatic rebasing / merge commit blocking [`e599917`](https://github.com/inspect-js/has-bigints/commit/e599917fd1f751c9a6c0daac70acb243f8c3a01d) +- [actions] add "Allow Edits" workflow [`bd0126e`](https://github.com/inspect-js/has-bigints/commit/bd0126eba2d67e9b9d588bced34413f507698154) +- [readme] remove travis badge [`8e02a73`](https://github.com/inspect-js/has-bigints/commit/8e02a73db34827d24d2945f2db822973a0b49925) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `auto-changelog`, `safe-publish-latest` [`95859f2`](https://github.com/inspect-js/has-bigints/commit/95859f28f23f5733481c52a501063802cf64f75b) +- [Dev Deps] update `auto-changelog`, `in-publish`, `tape` [`0588f41`](https://github.com/inspect-js/has-bigints/commit/0588f415c6cc01d6b34668680044e03b2998e03f) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` [`5b024a6`](https://github.com/inspect-js/has-bigints/commit/5b024a664a8b7d2d2f750a4c11ce20c395b6f12a) +- [meta] add `version` scripts [`4788d61`](https://github.com/inspect-js/has-bigints/commit/4788d61101c009e4e2c1b4d944c263de06192c6a) +- [actions] switch Automatic Rebase workflow to `pull_request_target` event [`be0e0de`](https://github.com/inspect-js/has-bigints/commit/be0e0de08298dfe483c5d7a2675e5133abeabc53) +- [Dev Deps] update `auto-changelog`; add `aud` [`13a8d1b`](https://github.com/inspect-js/has-bigints/commit/13a8d1bf1f661871d890bfa174de9514f016cdd9) +- [actions] fix action name [`f873d9a`](https://github.com/inspect-js/has-bigints/commit/f873d9a2f10718662528a755b12c61202f4e4afa) +- [meta] add `funding` field [`1b51f49`](https://github.com/inspect-js/has-bigints/commit/1b51f4921df1faf85d2679a0e4ba97ef015a73b7) +- [Dev Deps] update `auto-changelog` [`2322461`](https://github.com/inspect-js/has-bigints/commit/2322461789810434c447439f155eb3ca23eb29fb) +- [Tests] only audit prod deps [`aabdade`](https://github.com/inspect-js/has-bigints/commit/aabdadeaa1e126b91a2fbd82263cc49651ff5e7b) + +## v1.0.0 - 2019-08-10 + +### Commits + +- [Tests] add `.travis.yml` [`9730412`](https://github.com/inspect-js/has-bigints/commit/973041241dc172474bb9457aad41790fe54fec88) +- Initial commit [`65f7c38`](https://github.com/inspect-js/has-bigints/commit/65f7c3889d9a98e214e26d650723cbfc49338463) +- [Tests] add tests [`e374a78`](https://github.com/inspect-js/has-bigints/commit/e374a78033d457badcd47e06752fdec7f62e6c39) +- readme [`5d39092`](https://github.com/inspect-js/has-bigints/commit/5d3909249da442867180fb747eef27543627d250) +- npm init [`1be2e3d`](https://github.com/inspect-js/has-bigints/commit/1be2e3d69db6718901e6845cfc38a07cc46dfd96) +- implementation [`b7bc812`](https://github.com/inspect-js/has-bigints/commit/b7bc8121db1fb1a827625c4cb0608935e3dcbe31) +- [Tests] add linting [`04533be`](https://github.com/inspect-js/has-bigints/commit/04533bef57f60e322238f71f32ee3ae0c988bac4) +- [meta] create FUNDING.yml [`cf824a7`](https://github.com/inspect-js/has-bigints/commit/cf824a7d02e867957d8db17ee0a4c70c8ee5ff23) +- Only apps should have lockfiles [`64e8242`](https://github.com/inspect-js/has-bigints/commit/64e82429f1dca99f624dc971ff13516dee28d353) diff --git a/tools/ui/node_modules/has-bigints/LICENSE b/tools/ui/node_modules/has-bigints/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..3900dd7e2ffe6d5205fde1cd3f890aa51ea36234 --- /dev/null +++ b/tools/ui/node_modules/has-bigints/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2019 Jordan Harband + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/has-bigints/README.md b/tools/ui/node_modules/has-bigints/README.md new file mode 100644 index 0000000000000000000000000000000000000000..69414e42573b251236d8be8624ae61d7d03e797d --- /dev/null +++ b/tools/ui/node_modules/has-bigints/README.md @@ -0,0 +1,39 @@ +# has-bigints [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +Determine if the JS environment has BigInt support. + +## Example + +```js +var hasBigInts = require('has-bigints'); + +hasBigInts() === true; // if the environment has native BigInt support. Not polyfillable, not forgeable. +``` + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[package-url]: https://npmjs.org/package/has-bigints +[npm-version-svg]: https://versionbadg.es/inspect-js/has-bigints.svg +[deps-svg]: https://david-dm.org/inspect-js/has-bigints.svg +[deps-url]: https://david-dm.org/inspect-js/has-bigints +[dev-deps-svg]: https://david-dm.org/inspect-js/has-bigints/dev-status.svg +[dev-deps-url]: https://david-dm.org/inspect-js/has-bigints#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/has-bigints.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/has-bigints.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/has-bigints.svg +[downloads-url]: https://npm-stat.com/charts.html?package=has-bigints +[codecov-image]: https://codecov.io/gh/inspect-js/has-bigints/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/inspect-js/has-bigints/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/has-bigints +[actions-url]: https://github.com/inspect-js/has-bigints/actions diff --git a/tools/ui/node_modules/has-bigints/index.d.ts b/tools/ui/node_modules/has-bigints/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..3bac6850be84b35d0ca19227ce69bf5ebc1a896a --- /dev/null +++ b/tools/ui/node_modules/has-bigints/index.d.ts @@ -0,0 +1,3 @@ +declare function hasNativeBigInts(): boolean; + +export = hasNativeBigInts; \ No newline at end of file diff --git a/tools/ui/node_modules/has-bigints/index.js b/tools/ui/node_modules/has-bigints/index.js new file mode 100644 index 0000000000000000000000000000000000000000..43f910d1577d3c88257eea048ee10c23cea5bf3a --- /dev/null +++ b/tools/ui/node_modules/has-bigints/index.js @@ -0,0 +1,11 @@ +'use strict'; + +var $BigInt = typeof BigInt !== 'undefined' && BigInt; + +/** @type {import('.')} */ +module.exports = function hasNativeBigInts() { + return typeof $BigInt === 'function' + && typeof BigInt === 'function' + && typeof $BigInt(42) === 'bigint' // eslint-disable-line no-magic-numbers + && typeof BigInt(42) === 'bigint'; // eslint-disable-line no-magic-numbers +}; diff --git a/tools/ui/node_modules/has-bigints/package.json b/tools/ui/node_modules/has-bigints/package.json new file mode 100644 index 0000000000000000000000000000000000000000..1d963945917c2b392f61cab7597cc1d3a86c8b92 --- /dev/null +++ b/tools/ui/node_modules/has-bigints/package.json @@ -0,0 +1,69 @@ +{ + "name": "has-bigints", + "version": "1.1.0", + "description": "Determine if the JS environment has BigInt support.", + "main": "index.js", + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"", + "prepublishOnly": "safe-publish-latest", + "prepublish": "not-in-publish || npm run prepublishOnly", + "lint": "eslint --ext=js,mjs .", + "postlint": "tsc && attw -P", + "pretest": "npm run lint", + "tests-only": "nyc tape 'test/**/*.js'", + "test": "npm run tests-only", + "posttest": "npx npm@'>= 10.2' audit --production" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/ljharb/has-bigints.git" + }, + "keywords": [ + "BigInt", + "bigints", + "typeof", + "ES2020" + ], + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/ljharb/has-bigints/issues" + }, + "homepage": "https://github.com/ljharb/has-bigints#readme", + "devDependencies": { + "@arethetypeswrong/cli": "^0.17.1", + "@ljharb/eslint-config": "^21.1.1", + "@ljharb/tsconfig": "^0.2.2", + "@types/tape": "^5.8.0", + "auto-changelog": "^2.5.0", + "encoding": "^0.1.13", + "eslint": "=8.8.0", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0", + "typescript": "next" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + }, + "engines": { + "node": ">= 0.4" + } +} diff --git a/tools/ui/node_modules/has-bigints/test/index.js b/tools/ui/node_modules/has-bigints/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..efbc98b5ba811e9678c6bc25c6577113773a07ab --- /dev/null +++ b/tools/ui/node_modules/has-bigints/test/index.js @@ -0,0 +1,44 @@ +'use strict'; + +var test = require('tape'); +var hasBigInts = require('..'); + +test('interface', function (t) { + t.equal(typeof hasBigInts, 'function', 'is a function'); + t.equal(typeof hasBigInts(), 'boolean', 'returns a boolean'); + t.end(); +}); + +test('BigInts are supported', { skip: !hasBigInts() }, function (t) { + t.equal(typeof BigInt, 'function', 'global BigInt is a function'); + if (typeof BigInt !== 'function') { + return; + } + + t.equal(BigInt(42), BigInt(42), '42n === 42n'); + t['throws']( + function () { BigInt(NaN); }, + RangeError, + 'NaN is not an integer; BigInt(NaN) throws' + ); + + t['throws']( + function () { BigInt(Infinity); }, + RangeError, + 'Infinity is not an integer; BigInt(Infinity) throws' + ); + + t['throws']( + function () { BigInt(1.1); }, + RangeError, + '1.1 is not an integer; BigInt(1.1) throws' + ); + + t.end(); +}); + +test('BigInts are not supported', { skip: hasBigInts() }, function (t) { + t.equal(typeof BigInt, 'undefined', 'global BigInt is undefined'); + + t.end(); +}); diff --git a/tools/ui/node_modules/has-bigints/tsconfig.json b/tools/ui/node_modules/has-bigints/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..6716d81ce28cf3af2a23d2d9237c7a3d53114217 --- /dev/null +++ b/tools/ui/node_modules/has-bigints/tsconfig.json @@ -0,0 +1,9 @@ +{ + "extends": "@ljharb/tsconfig", + "compilerOptions": { + "target": "ES2021", + }, + "exclude": [ + "coverage" + ] +} diff --git a/tools/ui/node_modules/has-flag/index.d.ts b/tools/ui/node_modules/has-flag/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a0a48c89112785902cb109a27475840fd0952de8 --- /dev/null +++ b/tools/ui/node_modules/has-flag/index.d.ts @@ -0,0 +1,39 @@ +/** +Check if [`argv`](https://nodejs.org/docs/latest/api/process.html#process_process_argv) has a specific flag. + +@param flag - CLI flag to look for. The `--` prefix is optional. +@param argv - CLI arguments. Default: `process.argv`. +@returns Whether the flag exists. + +@example +``` +// $ ts-node foo.ts -f --unicorn --foo=bar -- --rainbow + +// foo.ts +import hasFlag = require('has-flag'); + +hasFlag('unicorn'); +//=> true + +hasFlag('--unicorn'); +//=> true + +hasFlag('f'); +//=> true + +hasFlag('-f'); +//=> true + +hasFlag('foo=bar'); +//=> true + +hasFlag('foo'); +//=> false + +hasFlag('rainbow'); +//=> false +``` +*/ +declare function hasFlag(flag: string, argv?: string[]): boolean; + +export = hasFlag; diff --git a/tools/ui/node_modules/has-flag/index.js b/tools/ui/node_modules/has-flag/index.js new file mode 100644 index 0000000000000000000000000000000000000000..b6f80b1f8ffd7658a11af977a9df3c296008d4cd --- /dev/null +++ b/tools/ui/node_modules/has-flag/index.js @@ -0,0 +1,8 @@ +'use strict'; + +module.exports = (flag, argv = process.argv) => { + const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--'); + const position = argv.indexOf(prefix + flag); + const terminatorPosition = argv.indexOf('--'); + return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition); +}; diff --git a/tools/ui/node_modules/has-flag/license b/tools/ui/node_modules/has-flag/license new file mode 100644 index 0000000000000000000000000000000000000000..e7af2f77107d73046421ef56c4684cbfdd3c1e89 --- /dev/null +++ b/tools/ui/node_modules/has-flag/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/has-flag/package.json b/tools/ui/node_modules/has-flag/package.json new file mode 100644 index 0000000000000000000000000000000000000000..a9cba4b856d046212a2a2f13fb911ae1deb4c3b5 --- /dev/null +++ b/tools/ui/node_modules/has-flag/package.json @@ -0,0 +1,46 @@ +{ + "name": "has-flag", + "version": "4.0.0", + "description": "Check if argv has a specific flag", + "license": "MIT", + "repository": "sindresorhus/has-flag", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "sindresorhus.com" + }, + "engines": { + "node": ">=8" + }, + "scripts": { + "test": "xo && ava && tsd" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "has", + "check", + "detect", + "contains", + "find", + "flag", + "cli", + "command-line", + "argv", + "process", + "arg", + "args", + "argument", + "arguments", + "getopt", + "minimist", + "optimist" + ], + "devDependencies": { + "ava": "^1.4.1", + "tsd": "^0.7.2", + "xo": "^0.24.0" + } +} diff --git a/tools/ui/node_modules/has-flag/readme.md b/tools/ui/node_modules/has-flag/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..3f72dff29a69612c14eaec559e2a11bcced48b5b --- /dev/null +++ b/tools/ui/node_modules/has-flag/readme.md @@ -0,0 +1,89 @@ +# has-flag [![Build Status](https://travis-ci.org/sindresorhus/has-flag.svg?branch=master)](https://travis-ci.org/sindresorhus/has-flag) + +> Check if [`argv`](https://nodejs.org/docs/latest/api/process.html#process_process_argv) has a specific flag + +Correctly stops looking after an `--` argument terminator. + +--- + +
+ + Get professional support for this package with a Tidelift subscription + +
+ + Tidelift helps make open source sustainable for maintainers while giving companies
assurances about security, maintenance, and licensing for their dependencies. + +
+ +--- + + +## Install + +``` +$ npm install has-flag +``` + + +## Usage + +```js +// foo.js +const hasFlag = require('has-flag'); + +hasFlag('unicorn'); +//=> true + +hasFlag('--unicorn'); +//=> true + +hasFlag('f'); +//=> true + +hasFlag('-f'); +//=> true + +hasFlag('foo=bar'); +//=> true + +hasFlag('foo'); +//=> false + +hasFlag('rainbow'); +//=> false +``` + +``` +$ node foo.js -f --unicorn --foo=bar -- --rainbow +``` + + +## API + +### hasFlag(flag, [argv]) + +Returns a boolean for whether the flag exists. + +#### flag + +Type: `string` + +CLI flag to look for. The `--` prefix is optional. + +#### argv + +Type: `string[]`
+Default: `process.argv` + +CLI arguments. + + +## Security + +To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure. + + +## License + +MIT © [Sindre Sorhus](https://sindresorhus.com) diff --git a/tools/ui/node_modules/has-property-descriptors/.eslintrc b/tools/ui/node_modules/has-property-descriptors/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..2fcc002b0a7f59de19f8b130d5b09bfeb99124a6 --- /dev/null +++ b/tools/ui/node_modules/has-property-descriptors/.eslintrc @@ -0,0 +1,13 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "func-name-matching": 0, + "id-length": 0, + "new-cap": [2, { + "capIsNewExceptions": ["GetIntrinsic"], + }], + }, +} diff --git a/tools/ui/node_modules/has-property-descriptors/.github/FUNDING.yml b/tools/ui/node_modules/has-property-descriptors/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..817aacf1f4268093d88f152efd214e45ef6a7bc7 --- /dev/null +++ b/tools/ui/node_modules/has-property-descriptors/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/has-property-descriptors +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/has-property-descriptors/.nycrc b/tools/ui/node_modules/has-property-descriptors/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..bdd626ce91477abbdd489b79988baebadbd3c897 --- /dev/null +++ b/tools/ui/node_modules/has-property-descriptors/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/has-property-descriptors/CHANGELOG.md b/tools/ui/node_modules/has-property-descriptors/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..19c8a959c6153dd7dd01c4c249b7ccd7059f31e9 --- /dev/null +++ b/tools/ui/node_modules/has-property-descriptors/CHANGELOG.md @@ -0,0 +1,35 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.0.2](https://github.com/inspect-js/has-property-descriptors/compare/v1.0.1...v1.0.2) - 2024-02-12 + +### Commits + +- [Refactor] use `es-define-property` [`f93a8c8`](https://github.com/inspect-js/has-property-descriptors/commit/f93a8c85eba70cbceab500f2619fb5cce73a1805) +- [Dev Deps] update `aud`, `npmignore`, `tape` [`42b0c9d`](https://github.com/inspect-js/has-property-descriptors/commit/42b0c9d1c23e747755f0f2924923c418ea34a9ee) +- [Deps] update `get-intrinsic` [`35e9b46`](https://github.com/inspect-js/has-property-descriptors/commit/35e9b46a7f14331bf0de98b644dd803676746037) + +## [v1.0.1](https://github.com/inspect-js/has-property-descriptors/compare/v1.0.0...v1.0.1) - 2023-10-20 + +### Commits + +- [meta] use `npmignore` to autogenerate an npmignore file [`5bbf4da`](https://github.com/inspect-js/has-property-descriptors/commit/5bbf4dae1b58950d87bb3af508bee7513e640868) +- [actions] update rebase action to use reusable workflow [`3a5585b`](https://github.com/inspect-js/has-property-descriptors/commit/3a5585bf74988f71a8f59e67a07d594e62c51fd8) +- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `tape` [`e5c1212`](https://github.com/inspect-js/has-property-descriptors/commit/e5c1212048a8fda549794c47863724ca60b89cae) +- [Dev Deps] update `aud`, `tape` [`e942917`](https://github.com/inspect-js/has-property-descriptors/commit/e942917b6c2f7c090d5623048989cf20d0834ebf) +- [Deps] update `get-intrinsic` [`f4a44ec`](https://github.com/inspect-js/has-property-descriptors/commit/f4a44ec6d94146fa6c550d3c15c31a2062c83ef4) +- [Deps] update `get-intrinsic` [`eeb275b`](https://github.com/inspect-js/has-property-descriptors/commit/eeb275b473e5d72ca843b61ca25cfcb06a5d4300) + +## v1.0.0 - 2022-04-14 + +### Commits + +- Initial implementation, tests [`303559f`](https://github.com/inspect-js/has-property-descriptors/commit/303559f2a72dfe7111573a1aec475ed4a184c35a) +- Initial commit [`3a7ca2d`](https://github.com/inspect-js/has-property-descriptors/commit/3a7ca2dc49f1fff0279a28bb16265e7615e14749) +- read me [`dd73dce`](https://github.com/inspect-js/has-property-descriptors/commit/dd73dce09d89d0f7a4a6e3b1e562a506f979a767) +- npm init [`c1e6557`](https://github.com/inspect-js/has-property-descriptors/commit/c1e655779de632d68cb944c50da6b71bcb7b8c85) +- Only apps should have lockfiles [`e72f7c6`](https://github.com/inspect-js/has-property-descriptors/commit/e72f7c68de534b2d273ee665f8b18d4ecc7f70b0) diff --git a/tools/ui/node_modules/has-property-descriptors/LICENSE b/tools/ui/node_modules/has-property-descriptors/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..2e7b9a3eacf263cb418f4c16b087290ef78c39b2 --- /dev/null +++ b/tools/ui/node_modules/has-property-descriptors/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Inspect JS + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/has-property-descriptors/README.md b/tools/ui/node_modules/has-property-descriptors/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d81fbd99e91a3ec97fc930ffb985819dacae39a6 --- /dev/null +++ b/tools/ui/node_modules/has-property-descriptors/README.md @@ -0,0 +1,43 @@ +# has-property-descriptors [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![dependency status][deps-svg]][deps-url] +[![dev dependency status][dev-deps-svg]][dev-deps-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +Does the environment have full property descriptor support? Handles IE 8's broken defineProperty/gOPD. + +## Example + +```js +var hasPropertyDescriptors = require('has-property-descriptors'); +var assert = require('assert'); + +assert.equal(hasPropertyDescriptors(), true); // will be `false` in IE 6-8, and ES5 engines + +// Arrays can not have their length `[[Defined]]` in some engines +assert.equal(hasPropertyDescriptors.hasArrayLengthDefineBug(), false); // will be `true` in Firefox 4-22, and node v0.6 +``` + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[package-url]: https://npmjs.org/package/has-property-descriptors +[npm-version-svg]: https://versionbadg.es/inspect-js/has-property-descriptors.svg +[deps-svg]: https://david-dm.org/inspect-js/has-property-descriptors.svg +[deps-url]: https://david-dm.org/inspect-js/has-property-descriptors +[dev-deps-svg]: https://david-dm.org/inspect-js/has-property-descriptors/dev-status.svg +[dev-deps-url]: https://david-dm.org/inspect-js/has-property-descriptors#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/has-property-descriptors.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/has-property-descriptors.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/has-property-descriptors.svg +[downloads-url]: https://npm-stat.com/charts.html?package=has-property-descriptors +[codecov-image]: https://codecov.io/gh/inspect-js/has-property-descriptors/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/inspect-js/has-property-descriptors/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/has-property-descriptors +[actions-url]: https://github.com/inspect-js/has-property-descriptors/actions diff --git a/tools/ui/node_modules/has-property-descriptors/index.js b/tools/ui/node_modules/has-property-descriptors/index.js new file mode 100644 index 0000000000000000000000000000000000000000..04804379cb13a68f351905f39b1d85d128d0720a --- /dev/null +++ b/tools/ui/node_modules/has-property-descriptors/index.js @@ -0,0 +1,22 @@ +'use strict'; + +var $defineProperty = require('es-define-property'); + +var hasPropertyDescriptors = function hasPropertyDescriptors() { + return !!$defineProperty; +}; + +hasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() { + // node v0.6 has a bug where array lengths can be Set but not Defined + if (!$defineProperty) { + return null; + } + try { + return $defineProperty([], 'length', { value: 1 }).length !== 1; + } catch (e) { + // In Firefox 4-22, defining length on an array throws an exception. + return true; + } +}; + +module.exports = hasPropertyDescriptors; diff --git a/tools/ui/node_modules/has-property-descriptors/package.json b/tools/ui/node_modules/has-property-descriptors/package.json new file mode 100644 index 0000000000000000000000000000000000000000..7e70218b478caca5c0ecd4b58b2e62f23eb28003 --- /dev/null +++ b/tools/ui/node_modules/has-property-descriptors/package.json @@ -0,0 +1,77 @@ +{ + "name": "has-property-descriptors", + "version": "1.0.2", + "description": "Does the environment have full property descriptor support? Handles IE 8's broken defineProperty/gOPD.", + "main": "index.js", + "exports": { + ".": "./index.js", + "./package.json": "./package.json" + }, + "sideEffects": false, + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublishOnly": "safe-publish-latest", + "prepublish": "not-in-publish || npm run prepublishOnly", + "pretest": "npm run lint", + "prelint": "evalmd README.md", + "lint": "eslint --ext=js,mjs .", + "tests-only": "nyc tape 'test/**/*.js'", + "test": "npm run tests-only", + "posttest": "aud --production", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/inspect-js/has-property-descriptors.git" + }, + "keywords": [ + "property", + "descriptors", + "has", + "environment", + "env", + "defineProperty", + "getOwnPropertyDescriptor" + ], + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/inspect-js/has-property-descriptors/issues" + }, + "homepage": "https://github.com/inspect-js/has-property-descriptors#readme", + "devDependencies": { + "@ljharb/eslint-config": "^21.1.0", + "aud": "^2.0.4", + "auto-changelog": "^2.4.0", + "eslint": "=8.8.0", + "evalmd": "^0.0.19", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "tape": "^5.7.4" + }, + "dependencies": { + "es-define-property": "^1.0.0" + }, + "testling": { + "files": "test/index.js" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + } +} diff --git a/tools/ui/node_modules/has-property-descriptors/test/index.js b/tools/ui/node_modules/has-property-descriptors/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..7f02bd3e68e63a7e8ff2ee3016a57dfe35463918 --- /dev/null +++ b/tools/ui/node_modules/has-property-descriptors/test/index.js @@ -0,0 +1,57 @@ +'use strict'; + +var test = require('tape'); + +var hasPropertyDescriptors = require('../'); + +var sentinel = {}; + +test('hasPropertyDescriptors', function (t) { + t.equal(typeof hasPropertyDescriptors, 'function', 'is a function'); + t.equal(typeof hasPropertyDescriptors.hasArrayLengthDefineBug, 'function', '`hasArrayLengthDefineBug` property is a function'); + + var yes = hasPropertyDescriptors(); + t.test('property descriptors', { skip: !yes }, function (st) { + var o = { a: sentinel }; + + st.deepEqual( + Object.getOwnPropertyDescriptor(o, 'a'), + { + configurable: true, + enumerable: true, + value: sentinel, + writable: true + }, + 'has expected property descriptor' + ); + + Object.defineProperty(o, 'a', { enumerable: false, writable: false }); + + st.deepEqual( + Object.getOwnPropertyDescriptor(o, 'a'), + { + configurable: true, + enumerable: false, + value: sentinel, + writable: false + }, + 'has expected property descriptor after [[Define]]' + ); + + st.end(); + }); + + var arrayBug = hasPropertyDescriptors.hasArrayLengthDefineBug(); + t.test('defining array lengths', { skip: !yes || arrayBug }, function (st) { + var arr = [1, , 3]; // eslint-disable-line no-sparse-arrays + st.equal(arr.length, 3, 'array starts with length 3'); + + Object.defineProperty(arr, 'length', { value: 5 }); + + st.equal(arr.length, 5, 'array ends with length 5'); + + st.end(); + }); + + t.end(); +}); diff --git a/tools/ui/node_modules/has-proto/.eslintrc b/tools/ui/node_modules/has-proto/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..3b5d9e90ec405f85dd7f9066656efccc51193697 --- /dev/null +++ b/tools/ui/node_modules/has-proto/.eslintrc @@ -0,0 +1,5 @@ +{ + "root": true, + + "extends": "@ljharb", +} diff --git a/tools/ui/node_modules/has-proto/.github/FUNDING.yml b/tools/ui/node_modules/has-proto/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..613705c7eb37d52c2ab1c67862b167714b9b2f57 --- /dev/null +++ b/tools/ui/node_modules/has-proto/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/has-proto +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/has-proto/CHANGELOG.md b/tools/ui/node_modules/has-proto/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..3c42363f0d59e65e2965a67b477fe6cdaf94bb62 --- /dev/null +++ b/tools/ui/node_modules/has-proto/CHANGELOG.md @@ -0,0 +1,61 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.2.0](https://github.com/inspect-js/has-proto/compare/v1.1.0...v1.2.0) - 2024-12-06 + +### Commits + +- [Refactor] use `dunder-proto` instead of `call-bind` [`6e5e76c`](https://github.com/inspect-js/has-proto/commit/6e5e76ce3bf4c01ebb99b38dcd61bee1ba35073f) +- [actions] split out node 10-20, and 20+ [`3b8e9e6`](https://github.com/inspect-js/has-proto/commit/3b8e9e651431ef5e9725dae68881b8107e812ee0) +- [Dev Deps] update `@ljharb/tsconfig`, `gopd` [`57bcd00`](https://github.com/inspect-js/has-proto/commit/57bcd000625c7d1e7f41fd10b4a8e1ea380029dd) +- [actions] skip `npm ls` in node < 10 [`ce3a4d7`](https://github.com/inspect-js/has-proto/commit/ce3a4d76d4f15d94540cb5f2ae50967cc6299ee3) + +## [v1.1.0](https://github.com/inspect-js/has-proto/compare/v1.0.3...v1.1.0) - 2024-12-01 + +### Commits + +- [New] add `accessor` and `mutator` endpoints [`144f6a9`](https://github.com/inspect-js/has-proto/commit/144f6a9c2a3925f25058d5d5ea7eab3be57767d9) +- [types] use shared config [`8b597cf`](https://github.com/inspect-js/has-proto/commit/8b597cff2b09f0351bc357cac0e0c7b0c8bb7e70) +- [Refactor] cache result at module level [`88418bd`](https://github.com/inspect-js/has-proto/commit/88418bde7e0c37c7d9aa6cc79150e774004c01d8) +- [Dev Deps] update `@ljharb/eslint-config`, `auto-changelog`, `tape` [`d246200`](https://github.com/inspect-js/has-proto/commit/d246200bae6ceceebb495df7f8eb0f27a017b63f) +- [Deps] update `gopd`, `reflect.getprototypeof` [`6f72364`](https://github.com/inspect-js/has-proto/commit/6f723645da9b5bef0aaae4a1aa66c07a1fed179f) +- [Tests] add `@arethetypeswrong/cli` [`8194e1a`](https://github.com/inspect-js/has-proto/commit/8194e1a607233f63c5bd0b91112c0423b3296ac9) +- [Tests] replace `aud` with `npm audit` [`fd7ad11`](https://github.com/inspect-js/has-proto/commit/fd7ad111dc35488b3200a763204dba0f6087defc) +- [Dev Deps] update `@types/tape` [`2695808`](https://github.com/inspect-js/has-proto/commit/26958086aec0b1cbfdddd4f10e54d2de1facf85c) +- [Dev Deps] add missing peer dep [`fa4b2f7`](https://github.com/inspect-js/has-proto/commit/fa4b2f77f7c0071e1c06b5590c9bada8e6b2edce) + +## [v1.0.3](https://github.com/inspect-js/has-proto/compare/v1.0.2...v1.0.3) - 2024-02-19 + +### Commits + +- [types] add missing declaration file [`26ecade`](https://github.com/inspect-js/has-proto/commit/26ecade05d253bb5dc376945ee3186d1fbe334f8) + +## [v1.0.2](https://github.com/inspect-js/has-proto/compare/v1.0.1...v1.0.2) - 2024-02-19 + +### Commits + +- add types [`6435262`](https://github.com/inspect-js/has-proto/commit/64352626cf511c0276d5f4bb6be770a0bf0f8524) +- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `npmignore`, `tape` [`f16a5e4`](https://github.com/inspect-js/has-proto/commit/f16a5e4121651e551271419f9d60fdd3561fd82c) +- [Refactor] tiny cleanup [`d1f1a4b`](https://github.com/inspect-js/has-proto/commit/d1f1a4bdc135f115a10f148ce302676224534702) +- [meta] add `sideEffects` flag [`e7ab1a6`](https://github.com/inspect-js/has-proto/commit/e7ab1a6f153b3e80dee68d1748b71e46767a0531) + +## [v1.0.1](https://github.com/inspect-js/has-proto/compare/v1.0.0...v1.0.1) - 2022-12-21 + +### Commits + +- [meta] correct URLs and description [`ef34483`](https://github.com/inspect-js/has-proto/commit/ef34483ca0d35680f271b6b96e35526151b25dfc) +- [patch] add an additional criteria [`e81959e`](https://github.com/inspect-js/has-proto/commit/e81959ed7c7a77fbf459f00cb4ef824f1099497f) +- [Dev Deps] update `aud` [`2bec2c4`](https://github.com/inspect-js/has-proto/commit/2bec2c47b072b122ff5443fba0263f6dc649531f) + +## v1.0.0 - 2022-12-12 + +### Commits + +- Initial implementation, tests, readme [`6886fea`](https://github.com/inspect-js/has-proto/commit/6886fea578f67daf69a7920b2eb7637ea6ebb0bc) +- Initial commit [`99129c8`](https://github.com/inspect-js/has-proto/commit/99129c8f42471ac89cb681ba9cb9d52a583eb94f) +- npm init [`2844ad8`](https://github.com/inspect-js/has-proto/commit/2844ad8e75b84d66a46765b3bab9d2e8ea692e10) +- Only apps should have lockfiles [`c65bc5e`](https://github.com/inspect-js/has-proto/commit/c65bc5e40b9004463f7336d47c67245fb139a36a) diff --git a/tools/ui/node_modules/has-proto/LICENSE b/tools/ui/node_modules/has-proto/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..2e7b9a3eacf263cb418f4c16b087290ef78c39b2 --- /dev/null +++ b/tools/ui/node_modules/has-proto/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2022 Inspect JS + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/has-proto/README.md b/tools/ui/node_modules/has-proto/README.md new file mode 100644 index 0000000000000000000000000000000000000000..cd33cc16649cdb26f448f5c090ca7baf6fe81324 --- /dev/null +++ b/tools/ui/node_modules/has-proto/README.md @@ -0,0 +1,57 @@ +# has-proto [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +Does this environment have the ability to set the [[Prototype]] of an object on creation with `__proto__`? + +## Example + +```js +var hasProto = require('has-proto'); +var assert = require('assert'); + +assert.equal(typeof hasProto(), 'boolean'); + +var hasProtoAccessor = require('has-proto/accessor')(); +if (hasProtoAccessor) { + assert.equal([].__proto__, Array.prototype); +} else { + assert(!('__proto__' in Object.prototype)); +} + +var hasProtoMutator = require('has-proto/mutator'); +var obj = {}; +assert('toString' in obj); + +obj.__proto__ = null; +if (hasProtoMutator) { + assert(!('toString' in obj)); +} else { + assert('toString' in obj); + assert.equal(obj.__proto__, null); +} +``` + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[package-url]: https://npmjs.org/package/has-proto +[npm-version-svg]: https://versionbadg.es/inspect-js/has-proto.svg +[deps-svg]: https://david-dm.org/inspect-js/has-proto.svg +[deps-url]: https://david-dm.org/inspect-js/has-proto +[dev-deps-svg]: https://david-dm.org/inspect-js/has-proto/dev-status.svg +[dev-deps-url]: https://david-dm.org/inspect-js/has-proto#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/has-proto.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/has-proto.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/has-proto.svg +[downloads-url]: https://npm-stat.com/charts.html?package=has-proto +[codecov-image]: https://codecov.io/gh/inspect-js/has-proto/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/inspect-js/has-proto/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/has-proto +[actions-url]: https://github.com/inspect-js/has-proto/actions diff --git a/tools/ui/node_modules/has-proto/accessor.d.ts b/tools/ui/node_modules/has-proto/accessor.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..eb864800d7e58f28a1e067af498a0bac0d59a010 --- /dev/null +++ b/tools/ui/node_modules/has-proto/accessor.d.ts @@ -0,0 +1,3 @@ +declare function accessor(): boolean; + +export = accessor; \ No newline at end of file diff --git a/tools/ui/node_modules/has-proto/accessor.js b/tools/ui/node_modules/has-proto/accessor.js new file mode 100644 index 0000000000000000000000000000000000000000..e168cba3c3ba12764899885d6d34946cff900155 --- /dev/null +++ b/tools/ui/node_modules/has-proto/accessor.js @@ -0,0 +1,20 @@ +'use strict'; + +var result = require('./')(); + +var test = { + __proto__: null, + foo: {} +}; + +/** @type {import('./accessor')} */ +module.exports = function hasAccessor() { + /* eslint no-proto: 0 */ + return result + && !('toString' in test) + // eslint-disable-next-line no-extra-parens + && /** @type {{ __proto__?: typeof Object.prototype }} */ ({}).__proto__ === Object.prototype + // eslint-disable-next-line no-extra-parens + && /** @type {ReadonlyArray & { __proto__?: typeof Array.prototype }} */ ( + []).__proto__ === Array.prototype; +}; diff --git a/tools/ui/node_modules/has-proto/index.d.ts b/tools/ui/node_modules/has-proto/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..1f54f56f4319b6a9d8d41c5645d63598e5d653e6 --- /dev/null +++ b/tools/ui/node_modules/has-proto/index.d.ts @@ -0,0 +1,3 @@ +declare function hasProto(): boolean; + +export = hasProto; diff --git a/tools/ui/node_modules/has-proto/index.js b/tools/ui/node_modules/has-proto/index.js new file mode 100644 index 0000000000000000000000000000000000000000..293fda179fadd9cdf808029d906a8b75bfd7756b --- /dev/null +++ b/tools/ui/node_modules/has-proto/index.js @@ -0,0 +1,15 @@ +'use strict'; + +var test = { + __proto__: null, + foo: {} +}; + +// @ts-expect-error: TS errors on an inherited property for some reason +var result = { __proto__: test }.foo === test.foo + && !(test instanceof Object); + +/** @type {import('.')} */ +module.exports = function hasProto() { + return result; +}; diff --git a/tools/ui/node_modules/has-proto/mutator.d.ts b/tools/ui/node_modules/has-proto/mutator.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8a556565666540dff66a8a7d226a295404640331 --- /dev/null +++ b/tools/ui/node_modules/has-proto/mutator.d.ts @@ -0,0 +1,3 @@ +declare function mutator(): boolean; + +export = mutator; \ No newline at end of file diff --git a/tools/ui/node_modules/has-proto/mutator.js b/tools/ui/node_modules/has-proto/mutator.js new file mode 100644 index 0000000000000000000000000000000000000000..d4aa3c24d5c04c454758a7da0e55f9c9967ccc54 --- /dev/null +++ b/tools/ui/node_modules/has-proto/mutator.js @@ -0,0 +1,33 @@ +'use strict'; + +var result = require('./')(); + +var test = { + __proto__: null, + foo: {} +}; + +var setter = require('dunder-proto/set'); + +/** @type {import('./mutator')} */ +module.exports = function hasMutator() { + if (!result) { + return false; + } + + var obj = { __proto__: test }; + // @ts-expect-error: TS errors on an inherited property for some reason + if (obj.foo !== test.foo) { + return false; + } + + if (!setter) { + return false; + } + + setter(obj, null); + if ('foo' in obj || 'toString' in obj) { + return false; + } + return true; +}; diff --git a/tools/ui/node_modules/has-proto/package.json b/tools/ui/node_modules/has-proto/package.json new file mode 100644 index 0000000000000000000000000000000000000000..598e76d9ca88fbdf5f51425b80613d8de923a4c4 --- /dev/null +++ b/tools/ui/node_modules/has-proto/package.json @@ -0,0 +1,91 @@ +{ + "name": "has-proto", + "version": "1.2.0", + "description": "Does this environment have the ability to get the [[Prototype]] of an object on creation with `__proto__`?", + "main": "index.js", + "exports": { + ".": "./index.js", + "./accessor": "./accessor.js", + "./mutator": "./mutator.js", + "./package.json": "./package.json" + }, + "sideEffects": false, + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublishOnly": "safe-publish-latest", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prelint": "evalmd README.md", + "lint": "eslint --ext=js,mjs .", + "postlint": "tsc -p . && attw -P", + "pretest": "npm run lint", + "tests-only": "tape 'test/**/*.js'", + "test": "npm run tests-only", + "posttest": "npx npm@'>=10.2' audit --production", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/inspect-js/has-proto.git" + }, + "keywords": [ + "prototype", + "proto", + "set", + "get", + "__proto__", + "getPrototypeOf", + "setPrototypeOf", + "has" + ], + "author": "Jordan Harband ", + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/inspect-js/has-proto/issues" + }, + "homepage": "https://github.com/inspect-js/has-proto#readme", + "testling": { + "files": "test/index.js" + }, + "devDependencies": { + "@arethetypeswrong/cli": "^0.17.0", + "@ljharb/eslint-config": "^21.1.1", + "@ljharb/tsconfig": "^0.2.2", + "@types/gopd": "^1.0.3", + "@types/tape": "^5.6.5", + "auto-changelog": "^2.5.0", + "encoding": "^0.1.13", + "eslint": "=8.8.0", + "evalmd": "^0.0.19", + "gopd": "^1.2.0", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "reflect.getprototypeof": "^1.0.7", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0", + "typescript": "next" + }, + "engines": { + "node": ">= 0.4" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows", + "types" + ] + }, + "dependencies": { + "dunder-proto": "^1.0.0" + } +} diff --git a/tools/ui/node_modules/has-proto/test/accessor.js b/tools/ui/node_modules/has-proto/test/accessor.js new file mode 100644 index 0000000000000000000000000000000000000000..dfd253180d13c0c11da25e4b89a692c2ba7560f4 --- /dev/null +++ b/tools/ui/node_modules/has-proto/test/accessor.js @@ -0,0 +1,34 @@ +'use strict'; + +var test = require('tape'); +var gPO = require('reflect.getprototypeof/polyfill')(); +var gOPD = require('gopd'); + +var hasProto = require('../'); +var hasProtoAccessor = require('../accessor'); + +var getter = require('dunder-proto/get'); + +test('hasProtoAccessor', function (t) { + var result = hasProtoAccessor(); + t.equal(typeof result, 'boolean', 'returns a boolean (' + result + ')'); + + var obj = { __proto__: null }; + if (result) { + t.notOk('toString' in obj, 'null object lacks toString'); + t.equal(gPO(obj), null); + if (gOPD && getter) { + t.equal(getter(obj), null); + } + } else if (hasProto()) { + t.notOk('toString' in obj, 'null object lacks toString'); + if (gOPD && getter) { + t.equal(getter(obj), null); + } + } else { + t.ok('toString' in obj, 'without proto, null object has toString'); + t.equal(gPO(obj), Object.prototype); + } + + t.end(); +}); diff --git a/tools/ui/node_modules/has-proto/test/index.js b/tools/ui/node_modules/has-proto/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..ab012e5e9cc6c48c047b0354f89acf86ca6c4028 --- /dev/null +++ b/tools/ui/node_modules/has-proto/test/index.js @@ -0,0 +1,28 @@ +'use strict'; + +var test = require('tape'); +var gPO = require('reflect.getprototypeof/polyfill')(); +var gOPD = require('gopd'); + +var hasProto = require('../'); + +var getter = require('dunder-proto/get'); + +test('hasProto', function (t) { + var result = hasProto(); + t.equal(typeof result, 'boolean', 'returns a boolean (' + result + ')'); + + var obj = { __proto__: null }; + if (result) { + t.notOk('toString' in obj, 'null object lacks toString'); + if (gOPD && getter) { + t.equal(getter(obj), null); + } + } else { + t.ok('toString' in obj, 'without proto, null object has toString'); + t.equal(gPO(obj), Object.prototype); + } + + t.end(); +}); + diff --git a/tools/ui/node_modules/has-proto/test/mutator.js b/tools/ui/node_modules/has-proto/test/mutator.js new file mode 100644 index 0000000000000000000000000000000000000000..e86e3f550264d6e06efd9ee316b2d153483390ec --- /dev/null +++ b/tools/ui/node_modules/has-proto/test/mutator.js @@ -0,0 +1,34 @@ +'use strict'; + +var test = require('tape'); +var gPO = require('reflect.getprototypeof/polyfill')(); +var gOPD = require('gopd'); + +var hasProto = require('../'); +var hasProtoMutator = require('../mutator'); + +var getter = require('dunder-proto/get'); + +test('hasProtoMutator', function (t) { + var result = hasProtoMutator(); + t.equal(typeof result, 'boolean', 'returns a boolean (' + result + ')'); + + var obj = { __proto__: null }; + if (result) { + t.notOk('toString' in obj, 'null object lacks toString'); + t.equal(gPO(obj), null); + if (gOPD && getter) { + t.equal(getter(obj), null); + } + } else if (hasProto()) { + t.notOk('toString' in obj, 'null object lacks toString'); + if (gOPD && getter) { + t.equal(getter(obj), null); + } + } else { + t.ok('toString' in obj, 'without proto, null object has toString'); + t.equal(gPO(obj), Object.prototype); + } + + t.end(); +}); diff --git a/tools/ui/node_modules/has-proto/tsconfig.json b/tools/ui/node_modules/has-proto/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..09fd66bdba1605066a703cf4e7517311bac63dec --- /dev/null +++ b/tools/ui/node_modules/has-proto/tsconfig.json @@ -0,0 +1,11 @@ +{ + "extends": "@ljharb/tsconfig", + "exclude": [ + "coverage", + ], + "compilerOptions": { + "typeRoots": [ + "types", + ], + }, +} diff --git a/tools/ui/node_modules/has-symbols/.eslintrc b/tools/ui/node_modules/has-symbols/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..2d9a66a8acdbacede413918d9c0c8eaaacee7457 --- /dev/null +++ b/tools/ui/node_modules/has-symbols/.eslintrc @@ -0,0 +1,11 @@ +{ + "root": true, + + "extends": "@ljharb", + + "rules": { + "max-statements-per-line": [2, { "max": 2 }], + "no-magic-numbers": 0, + "multiline-comment-style": 0, + } +} diff --git a/tools/ui/node_modules/has-symbols/.github/FUNDING.yml b/tools/ui/node_modules/has-symbols/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..04cf87e66ed8daa00712b7926d2ed63a9108c2ae --- /dev/null +++ b/tools/ui/node_modules/has-symbols/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/has-symbols +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/has-symbols/.nycrc b/tools/ui/node_modules/has-symbols/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..bdd626ce91477abbdd489b79988baebadbd3c897 --- /dev/null +++ b/tools/ui/node_modules/has-symbols/.nycrc @@ -0,0 +1,9 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/has-symbols/CHANGELOG.md b/tools/ui/node_modules/has-symbols/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..cc3cf8390d16d4568d961f93395b7d330c4ada27 --- /dev/null +++ b/tools/ui/node_modules/has-symbols/CHANGELOG.md @@ -0,0 +1,91 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.1.0](https://github.com/inspect-js/has-symbols/compare/v1.0.3...v1.1.0) - 2024-12-02 + +### Commits + +- [actions] update workflows [`548c0bf`](https://github.com/inspect-js/has-symbols/commit/548c0bf8c9b1235458df7a1c0490b0064647a282) +- [actions] further shard; update action deps [`bec56bb`](https://github.com/inspect-js/has-symbols/commit/bec56bb0fb44b43a786686b944875a3175cf3ff3) +- [meta] use `npmignore` to autogenerate an npmignore file [`ac81032`](https://github.com/inspect-js/has-symbols/commit/ac81032809157e0a079e5264e9ce9b6f1275777e) +- [New] add types [`6469cbf`](https://github.com/inspect-js/has-symbols/commit/6469cbff1866cfe367b2b3d181d9296ec14b2a3d) +- [actions] update rebase action to use reusable workflow [`9c9d4d0`](https://github.com/inspect-js/has-symbols/commit/9c9d4d0d8938e4b267acdf8e421f4e92d1716d72) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`adb5887`](https://github.com/inspect-js/has-symbols/commit/adb5887ca9444849b08beb5caaa9e1d42320cdfb) +- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `tape` [`13ec198`](https://github.com/inspect-js/has-symbols/commit/13ec198ec80f1993a87710af1606a1970b22c7cb) +- [Dev Deps] update `auto-changelog`, `core-js`, `tape` [`941be52`](https://github.com/inspect-js/has-symbols/commit/941be5248387cab1da72509b22acf3fdb223f057) +- [Tests] replace `aud` with `npm audit` [`74f49e9`](https://github.com/inspect-js/has-symbols/commit/74f49e9a9d17a443020784234a1c53ce765b3559) +- [Dev Deps] update `npmignore` [`9c0ac04`](https://github.com/inspect-js/has-symbols/commit/9c0ac0452a834f4c2a4b54044f2d6a89f17e9a70) +- [Dev Deps] add missing peer dep [`52337a5`](https://github.com/inspect-js/has-symbols/commit/52337a5621cced61f846f2afdab7707a8132cc12) + +## [v1.0.3](https://github.com/inspect-js/has-symbols/compare/v1.0.2...v1.0.3) - 2022-03-01 + +### Commits + +- [actions] use `node/install` instead of `node/run`; use `codecov` action [`518b28f`](https://github.com/inspect-js/has-symbols/commit/518b28f6c5a516cbccae30794e40aa9f738b1693) +- [meta] add `bugs` and `homepage` fields; reorder package.json [`c480b13`](https://github.com/inspect-js/has-symbols/commit/c480b13fd6802b557e1cef9749872cb5fdeef744) +- [actions] reuse common workflows [`01d0ee0`](https://github.com/inspect-js/has-symbols/commit/01d0ee0a8d97c0947f5edb73eb722027a77b2b07) +- [actions] update codecov uploader [`6424ebe`](https://github.com/inspect-js/has-symbols/commit/6424ebe86b2c9c7c3d2e9bd4413a4e4f168cb275) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `tape` [`dfa7e7f`](https://github.com/inspect-js/has-symbols/commit/dfa7e7ff38b594645d8c8222aab895157fa7e282) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `safe-publish-latest`, `tape` [`0c8d436`](https://github.com/inspect-js/has-symbols/commit/0c8d43685c45189cea9018191d4fd7eca91c9d02) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`9026554`](https://github.com/inspect-js/has-symbols/commit/902655442a1bf88e72b42345494ef0c60f5d36ab) +- [readme] add actions and codecov badges [`eaa9682`](https://github.com/inspect-js/has-symbols/commit/eaa9682f990f481d3acf7a1c7600bec36f7b3adc) +- [Dev Deps] update `eslint`, `tape` [`bc7a3ba`](https://github.com/inspect-js/has-symbols/commit/bc7a3ba46f27b7743f8a2579732d59d1b9ac791e) +- [Dev Deps] update `eslint`, `auto-changelog` [`0ace00a`](https://github.com/inspect-js/has-symbols/commit/0ace00af08a88cdd1e6ce0d60357d941c60c2d9f) +- [meta] use `prepublishOnly` script for npm 7+ [`093f72b`](https://github.com/inspect-js/has-symbols/commit/093f72bc2b0ed00c781f444922a5034257bf561d) +- [Tests] test on all 16 minors [`9b80d3d`](https://github.com/inspect-js/has-symbols/commit/9b80d3d9102529f04c20ec5b1fcc6e38426c6b03) + +## [v1.0.2](https://github.com/inspect-js/has-symbols/compare/v1.0.1...v1.0.2) - 2021-02-27 + +### Fixed + +- [Fix] use a universal way to get the original Symbol [`#11`](https://github.com/inspect-js/has-symbols/issues/11) + +### Commits + +- [Tests] migrate tests to Github Actions [`90ae798`](https://github.com/inspect-js/has-symbols/commit/90ae79820bdfe7bc703d67f5f3c5e205f98556d3) +- [meta] do not publish github action workflow files [`29e60a1`](https://github.com/inspect-js/has-symbols/commit/29e60a1b7c25c7f1acf7acff4a9320d0d10c49b4) +- [Tests] run `nyc` on all tests [`8476b91`](https://github.com/inspect-js/has-symbols/commit/8476b915650d360915abe2522505abf4b0e8f0ae) +- [readme] fix repo URLs, remove defunct badges [`126288e`](https://github.com/inspect-js/has-symbols/commit/126288ecc1797c0a40247a6b78bcb2e0bc5d7036) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `core-js`, `get-own-property-symbols` [`d84bdfa`](https://github.com/inspect-js/has-symbols/commit/d84bdfa48ac5188abbb4904b42614cd6c030940a) +- [Tests] fix linting errors [`0df3070`](https://github.com/inspect-js/has-symbols/commit/0df3070b981b6c9f2ee530c09189a7f5c6def839) +- [actions] add "Allow Edits" workflow [`1e6bc29`](https://github.com/inspect-js/has-symbols/commit/1e6bc29b188f32b9648657b07eda08504be5aa9c) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `tape` [`36cea2a`](https://github.com/inspect-js/has-symbols/commit/36cea2addd4e6ec435f35a2656b4e9ef82498e9b) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`1278338`](https://github.com/inspect-js/has-symbols/commit/127833801865fbc2cc8979beb9ca869c7bfe8222) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`1493254`](https://github.com/inspect-js/has-symbols/commit/1493254eda13db5fb8fc5e4a3e8324b3d196029d) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `core-js` [`b090bf2`](https://github.com/inspect-js/has-symbols/commit/b090bf214d3679a30edc1e2d729d466ab5183e1d) +- [actions] switch Automatic Rebase workflow to `pull_request_target` event [`4addb7a`](https://github.com/inspect-js/has-symbols/commit/4addb7ab4dc73f927ae99928d68817554fc21dc0) +- [Dev Deps] update `auto-changelog`, `tape` [`81d0baf`](https://github.com/inspect-js/has-symbols/commit/81d0baf3816096a89a8558e8043895f7a7d10d8b) +- [Dev Deps] update `auto-changelog`; add `aud` [`1a4e561`](https://github.com/inspect-js/has-symbols/commit/1a4e5612c25d91c3a03d509721d02630bc4fe3da) +- [readme] remove unused testling URLs [`3000941`](https://github.com/inspect-js/has-symbols/commit/3000941f958046e923ed8152edb1ef4a599e6fcc) +- [Tests] only audit prod deps [`692e974`](https://github.com/inspect-js/has-symbols/commit/692e9743c912410e9440207631a643a34b4741a1) +- [Dev Deps] update `@ljharb/eslint-config` [`51c946c`](https://github.com/inspect-js/has-symbols/commit/51c946c7f6baa793ec5390bb5a45cdce16b4ba76) + +## [v1.0.1](https://github.com/inspect-js/has-symbols/compare/v1.0.0...v1.0.1) - 2019-11-16 + +### Commits + +- [Tests] use shared travis-ci configs [`ce396c9`](https://github.com/inspect-js/has-symbols/commit/ce396c9419ff11c43d0da5d05cdbb79f7fb42229) +- [Tests] up to `node` `v12.4`, `v11.15`, `v10.15`, `v9.11`, `v8.15`, `v7.10`, `v6.17`, `v4.9`; use `nvm install-latest-npm` [`0690732`](https://github.com/inspect-js/has-symbols/commit/0690732801f47ab429f39ba1962f522d5c462d6b) +- [meta] add `auto-changelog` [`2163d0b`](https://github.com/inspect-js/has-symbols/commit/2163d0b7f36343076b8f947cd1667dd1750f26fc) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `core-js`, `safe-publish-latest`, `tape` [`8e0951f`](https://github.com/inspect-js/has-symbols/commit/8e0951f1a7a2e52068222b7bb73511761e6e4d9c) +- [actions] add automatic rebasing / merge commit blocking [`b09cdb7`](https://github.com/inspect-js/has-symbols/commit/b09cdb7cd7ee39e7a769878f56e2d6066f5ccd1d) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `safe-publish-latest`, `core-js`, `get-own-property-symbols`, `tape` [`1dd42cd`](https://github.com/inspect-js/has-symbols/commit/1dd42cd86183ed0c50f99b1062345c458babca91) +- [meta] create FUNDING.yml [`aa57a17`](https://github.com/inspect-js/has-symbols/commit/aa57a17b19708906d1927f821ea8e73394d84ca4) +- Only apps should have lockfiles [`a2d8bea`](https://github.com/inspect-js/has-symbols/commit/a2d8bea23a97d15c09eaf60f5b107fcf9a4d57aa) +- [Tests] use `npx aud` instead of `nsp` or `npm audit` with hoops [`9e96cb7`](https://github.com/inspect-js/has-symbols/commit/9e96cb783746cbed0c10ef78e599a8eaa7ebe193) +- [meta] add `funding` field [`a0b32cf`](https://github.com/inspect-js/has-symbols/commit/a0b32cf68e803f963c1639b6d47b0a9d6440bab0) +- [Dev Deps] update `safe-publish-latest` [`cb9f0a5`](https://github.com/inspect-js/has-symbols/commit/cb9f0a521a3a1790f1064d437edd33bb6c3d6af0) + +## v1.0.0 - 2016-09-19 + +### Commits + +- Tests. [`ecb6eb9`](https://github.com/inspect-js/has-symbols/commit/ecb6eb934e4883137f3f93b965ba5e0a98df430d) +- package.json [`88a337c`](https://github.com/inspect-js/has-symbols/commit/88a337cee0864a0da35f5d19e69ff0ef0150e46a) +- Initial commit [`42e1e55`](https://github.com/inspect-js/has-symbols/commit/42e1e5502536a2b8ac529c9443984acd14836b1c) +- Initial implementation. [`33f5cc6`](https://github.com/inspect-js/has-symbols/commit/33f5cc6cdff86e2194b081ee842bfdc63caf43fb) +- read me [`01f1170`](https://github.com/inspect-js/has-symbols/commit/01f1170188ff7cb1558aa297f6ba5b516c6d7b0c) diff --git a/tools/ui/node_modules/has-symbols/LICENSE b/tools/ui/node_modules/has-symbols/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..df31cbf3c064d00ba5f15a3bb13c957b598b96a1 --- /dev/null +++ b/tools/ui/node_modules/has-symbols/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2016 Jordan Harband + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/has-symbols/README.md b/tools/ui/node_modules/has-symbols/README.md new file mode 100644 index 0000000000000000000000000000000000000000..33905f0fc92c406715fef234ba43605c95390b30 --- /dev/null +++ b/tools/ui/node_modules/has-symbols/README.md @@ -0,0 +1,46 @@ +# has-symbols [![Version Badge][2]][1] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![dependency status][5]][6] +[![dev dependency status][7]][8] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][11]][1] + +Determine if the JS environment has Symbol support. Supports spec, or shams. + +## Example + +```js +var hasSymbols = require('has-symbols'); + +hasSymbols() === true; // if the environment has native Symbol support. Not polyfillable, not forgeable. + +var hasSymbolsKinda = require('has-symbols/shams'); +hasSymbolsKinda() === true; // if the environment has a Symbol sham that mostly follows the spec. +``` + +## Supported Symbol shams + - get-own-property-symbols [npm](https://www.npmjs.com/package/get-own-property-symbols) | [github](https://github.com/WebReflection/get-own-property-symbols) + - core-js [npm](https://www.npmjs.com/package/core-js) | [github](https://github.com/zloirock/core-js) + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[1]: https://npmjs.org/package/has-symbols +[2]: https://versionbadg.es/inspect-js/has-symbols.svg +[5]: https://david-dm.org/inspect-js/has-symbols.svg +[6]: https://david-dm.org/inspect-js/has-symbols +[7]: https://david-dm.org/inspect-js/has-symbols/dev-status.svg +[8]: https://david-dm.org/inspect-js/has-symbols#info=devDependencies +[11]: https://nodei.co/npm/has-symbols.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/has-symbols.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/has-symbols.svg +[downloads-url]: https://npm-stat.com/charts.html?package=has-symbols +[codecov-image]: https://codecov.io/gh/inspect-js/has-symbols/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/inspect-js/has-symbols/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/has-symbols +[actions-url]: https://github.com/inspect-js/has-symbols/actions diff --git a/tools/ui/node_modules/has-symbols/index.d.ts b/tools/ui/node_modules/has-symbols/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..9b98595004b23ce56854e4be1181217591e34776 --- /dev/null +++ b/tools/ui/node_modules/has-symbols/index.d.ts @@ -0,0 +1,3 @@ +declare function hasNativeSymbols(): boolean; + +export = hasNativeSymbols; \ No newline at end of file diff --git a/tools/ui/node_modules/has-symbols/index.js b/tools/ui/node_modules/has-symbols/index.js new file mode 100644 index 0000000000000000000000000000000000000000..fa65265a9d45a38560d60c71f0a3305802c39365 --- /dev/null +++ b/tools/ui/node_modules/has-symbols/index.js @@ -0,0 +1,14 @@ +'use strict'; + +var origSymbol = typeof Symbol !== 'undefined' && Symbol; +var hasSymbolSham = require('./shams'); + +/** @type {import('.')} */ +module.exports = function hasNativeSymbols() { + if (typeof origSymbol !== 'function') { return false; } + if (typeof Symbol !== 'function') { return false; } + if (typeof origSymbol('foo') !== 'symbol') { return false; } + if (typeof Symbol('bar') !== 'symbol') { return false; } + + return hasSymbolSham(); +}; diff --git a/tools/ui/node_modules/has-symbols/package.json b/tools/ui/node_modules/has-symbols/package.json new file mode 100644 index 0000000000000000000000000000000000000000..d835e20b957be00d24b62cfc3e7243cc9f133ca2 --- /dev/null +++ b/tools/ui/node_modules/has-symbols/package.json @@ -0,0 +1,111 @@ +{ + "name": "has-symbols", + "version": "1.1.0", + "description": "Determine if the JS environment has Symbol support. Supports spec, or shams.", + "main": "index.js", + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublishOnly": "safe-publish-latest", + "prepublish": "not-in-publish || npm run prepublishOnly", + "pretest": "npm run --silent lint", + "test": "npm run tests-only", + "posttest": "npx npm@'>=10.2' audit --production", + "tests-only": "npm run test:stock && npm run test:shams", + "test:stock": "nyc node test", + "test:staging": "nyc node --harmony --es-staging test", + "test:shams": "npm run --silent test:shams:getownpropertysymbols && npm run --silent test:shams:corejs", + "test:shams:corejs": "nyc node test/shams/core-js.js", + "test:shams:getownpropertysymbols": "nyc node test/shams/get-own-property-symbols.js", + "lint": "eslint --ext=js,mjs .", + "postlint": "tsc -p . && attw -P", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git://github.com/inspect-js/has-symbols.git" + }, + "keywords": [ + "Symbol", + "symbols", + "typeof", + "sham", + "polyfill", + "native", + "core-js", + "ES6" + ], + "author": { + "name": "Jordan Harband", + "email": "ljharb@gmail.com", + "url": "http://ljharb.codes" + }, + "contributors": [ + { + "name": "Jordan Harband", + "email": "ljharb@gmail.com", + "url": "http://ljharb.codes" + } + ], + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "license": "MIT", + "bugs": { + "url": "https://github.com/ljharb/has-symbols/issues" + }, + "homepage": "https://github.com/ljharb/has-symbols#readme", + "devDependencies": { + "@arethetypeswrong/cli": "^0.17.0", + "@ljharb/eslint-config": "^21.1.1", + "@ljharb/tsconfig": "^0.2.0", + "@types/core-js": "^2.5.8", + "@types/tape": "^5.6.5", + "auto-changelog": "^2.5.0", + "core-js": "^2.6.12", + "encoding": "^0.1.13", + "eslint": "=8.8.0", + "get-own-property-symbols": "^0.9.5", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0", + "typescript": "next" + }, + "testling": { + "files": "test/index.js", + "browsers": [ + "iexplore/6.0..latest", + "firefox/3.0..6.0", + "firefox/15.0..latest", + "firefox/nightly", + "chrome/4.0..10.0", + "chrome/20.0..latest", + "chrome/canary", + "opera/10.0..latest", + "opera/next", + "safari/4.0..latest", + "ipad/6.0..latest", + "iphone/6.0..latest", + "android-browser/4.2" + ] + }, + "engines": { + "node": ">= 0.4" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows", + "types" + ] + } +} diff --git a/tools/ui/node_modules/has-symbols/shams.d.ts b/tools/ui/node_modules/has-symbols/shams.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..8d0bf2435e7e4f5d6c01058b738243f6361b186b --- /dev/null +++ b/tools/ui/node_modules/has-symbols/shams.d.ts @@ -0,0 +1,3 @@ +declare function hasSymbolShams(): boolean; + +export = hasSymbolShams; \ No newline at end of file diff --git a/tools/ui/node_modules/has-symbols/shams.js b/tools/ui/node_modules/has-symbols/shams.js new file mode 100644 index 0000000000000000000000000000000000000000..f97b474105d705cc4acb88c32aaf60cfb28bf6b3 --- /dev/null +++ b/tools/ui/node_modules/has-symbols/shams.js @@ -0,0 +1,45 @@ +'use strict'; + +/** @type {import('./shams')} */ +/* eslint complexity: [2, 18], max-statements: [2, 33] */ +module.exports = function hasSymbols() { + if (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; } + if (typeof Symbol.iterator === 'symbol') { return true; } + + /** @type {{ [k in symbol]?: unknown }} */ + var obj = {}; + var sym = Symbol('test'); + var symObj = Object(sym); + if (typeof sym === 'string') { return false; } + + if (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; } + if (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; } + + // temp disabled per https://github.com/ljharb/object.assign/issues/17 + // if (sym instanceof Symbol) { return false; } + // temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4 + // if (!(symObj instanceof Symbol)) { return false; } + + // if (typeof Symbol.prototype.toString !== 'function') { return false; } + // if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; } + + var symVal = 42; + obj[sym] = symVal; + for (var _ in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop + if (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; } + + if (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; } + + var syms = Object.getOwnPropertySymbols(obj); + if (syms.length !== 1 || syms[0] !== sym) { return false; } + + if (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; } + + if (typeof Object.getOwnPropertyDescriptor === 'function') { + // eslint-disable-next-line no-extra-parens + var descriptor = /** @type {PropertyDescriptor} */ (Object.getOwnPropertyDescriptor(obj, sym)); + if (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; } + } + + return true; +}; diff --git a/tools/ui/node_modules/has-symbols/test/index.js b/tools/ui/node_modules/has-symbols/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..352129ca356c8ce4ba2e5e6b78c092f401e0f2da --- /dev/null +++ b/tools/ui/node_modules/has-symbols/test/index.js @@ -0,0 +1,22 @@ +'use strict'; + +var test = require('tape'); +var hasSymbols = require('../'); +var runSymbolTests = require('./tests'); + +test('interface', function (t) { + t.equal(typeof hasSymbols, 'function', 'is a function'); + t.equal(typeof hasSymbols(), 'boolean', 'returns a boolean'); + t.end(); +}); + +test('Symbols are supported', { skip: !hasSymbols() }, function (t) { + runSymbolTests(t); + t.end(); +}); + +test('Symbols are not supported', { skip: hasSymbols() }, function (t) { + t.equal(typeof Symbol, 'undefined', 'global Symbol is undefined'); + t.equal(typeof Object.getOwnPropertySymbols, 'undefined', 'Object.getOwnPropertySymbols does not exist'); + t.end(); +}); diff --git a/tools/ui/node_modules/has-symbols/test/shams/core-js.js b/tools/ui/node_modules/has-symbols/test/shams/core-js.js new file mode 100644 index 0000000000000000000000000000000000000000..1a29024ea215a7eefa9e372a75ac2d9c1b9e2abb --- /dev/null +++ b/tools/ui/node_modules/has-symbols/test/shams/core-js.js @@ -0,0 +1,29 @@ +'use strict'; + +var test = require('tape'); + +if (typeof Symbol === 'function' && typeof Symbol() === 'symbol') { + test('has native Symbol support', function (t) { + t.equal(typeof Symbol, 'function'); + t.equal(typeof Symbol(), 'symbol'); + t.end(); + }); + // @ts-expect-error TS is stupid and doesn't know about top level return + return; +} + +var hasSymbols = require('../../shams'); + +test('polyfilled Symbols', function (t) { + /* eslint-disable global-require */ + t.equal(hasSymbols(), false, 'hasSymbols is false before polyfilling'); + require('core-js/fn/symbol'); + require('core-js/fn/symbol/to-string-tag'); + + require('../tests')(t); + + var hasSymbolsAfter = hasSymbols(); + t.equal(hasSymbolsAfter, true, 'hasSymbols is true after polyfilling'); + /* eslint-enable global-require */ + t.end(); +}); diff --git a/tools/ui/node_modules/has-symbols/test/shams/get-own-property-symbols.js b/tools/ui/node_modules/has-symbols/test/shams/get-own-property-symbols.js new file mode 100644 index 0000000000000000000000000000000000000000..e0296f8e25c8f10b0b4fbb428b8d92c04c5373a9 --- /dev/null +++ b/tools/ui/node_modules/has-symbols/test/shams/get-own-property-symbols.js @@ -0,0 +1,29 @@ +'use strict'; + +var test = require('tape'); + +if (typeof Symbol === 'function' && typeof Symbol() === 'symbol') { + test('has native Symbol support', function (t) { + t.equal(typeof Symbol, 'function'); + t.equal(typeof Symbol(), 'symbol'); + t.end(); + }); + // @ts-expect-error TS is stupid and doesn't know about top level return + return; +} + +var hasSymbols = require('../../shams'); + +test('polyfilled Symbols', function (t) { + /* eslint-disable global-require */ + t.equal(hasSymbols(), false, 'hasSymbols is false before polyfilling'); + + require('get-own-property-symbols'); + + require('../tests')(t); + + var hasSymbolsAfter = hasSymbols(); + t.equal(hasSymbolsAfter, true, 'hasSymbols is true after polyfilling'); + /* eslint-enable global-require */ + t.end(); +}); diff --git a/tools/ui/node_modules/has-symbols/test/tests.js b/tools/ui/node_modules/has-symbols/test/tests.js new file mode 100644 index 0000000000000000000000000000000000000000..66a2cb800239b52fded1d03a2747967f17c92251 --- /dev/null +++ b/tools/ui/node_modules/has-symbols/test/tests.js @@ -0,0 +1,58 @@ +'use strict'; + +/** @type {(t: import('tape').Test) => false | void} */ +// eslint-disable-next-line consistent-return +module.exports = function runSymbolTests(t) { + t.equal(typeof Symbol, 'function', 'global Symbol is a function'); + + if (typeof Symbol !== 'function') { return false; } + + t.notEqual(Symbol(), Symbol(), 'two symbols are not equal'); + + /* + t.equal( + Symbol.prototype.toString.call(Symbol('foo')), + Symbol.prototype.toString.call(Symbol('foo')), + 'two symbols with the same description stringify the same' + ); + */ + + /* + var foo = Symbol('foo'); + + t.notEqual( + String(foo), + String(Symbol('bar')), + 'two symbols with different descriptions do not stringify the same' + ); + */ + + t.equal(typeof Symbol.prototype.toString, 'function', 'Symbol#toString is a function'); + // t.equal(String(foo), Symbol.prototype.toString.call(foo), 'Symbol#toString equals String of the same symbol'); + + t.equal(typeof Object.getOwnPropertySymbols, 'function', 'Object.getOwnPropertySymbols is a function'); + + /** @type {{ [k in symbol]?: unknown }} */ + var obj = {}; + var sym = Symbol('test'); + var symObj = Object(sym); + t.notEqual(typeof sym, 'string', 'Symbol is not a string'); + t.equal(Object.prototype.toString.call(sym), '[object Symbol]', 'symbol primitive Object#toStrings properly'); + t.equal(Object.prototype.toString.call(symObj), '[object Symbol]', 'symbol primitive Object#toStrings properly'); + + var symVal = 42; + obj[sym] = symVal; + // eslint-disable-next-line no-restricted-syntax, no-unused-vars + for (var _ in obj) { t.fail('symbol property key was found in for..in of object'); } + + t.deepEqual(Object.keys(obj), [], 'no enumerable own keys on symbol-valued object'); + t.deepEqual(Object.getOwnPropertyNames(obj), [], 'no own names on symbol-valued object'); + t.deepEqual(Object.getOwnPropertySymbols(obj), [sym], 'one own symbol on symbol-valued object'); + t.equal(Object.prototype.propertyIsEnumerable.call(obj, sym), true, 'symbol is enumerable'); + t.deepEqual(Object.getOwnPropertyDescriptor(obj, sym), { + configurable: true, + enumerable: true, + value: 42, + writable: true + }, 'property descriptor is correct'); +}; diff --git a/tools/ui/node_modules/has-symbols/tsconfig.json b/tools/ui/node_modules/has-symbols/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..ba99af43fe36a32096fd9bdd451c200215f9293e --- /dev/null +++ b/tools/ui/node_modules/has-symbols/tsconfig.json @@ -0,0 +1,10 @@ +{ + "extends": "@ljharb/tsconfig", + "compilerOptions": { + "target": "ES2021", + "maxNodeModuleJsDepth": 0, + }, + "exclude": [ + "coverage" + ] +} diff --git a/tools/ui/node_modules/has-tostringtag/.eslintrc b/tools/ui/node_modules/has-tostringtag/.eslintrc new file mode 100644 index 0000000000000000000000000000000000000000..3b5d9e90ec405f85dd7f9066656efccc51193697 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/.eslintrc @@ -0,0 +1,5 @@ +{ + "root": true, + + "extends": "@ljharb", +} diff --git a/tools/ui/node_modules/has-tostringtag/.github/FUNDING.yml b/tools/ui/node_modules/has-tostringtag/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..7a450e70826f140f9e92de4b5bc6967db78eafca --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/has-tostringtag +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2'] diff --git a/tools/ui/node_modules/has-tostringtag/.nycrc b/tools/ui/node_modules/has-tostringtag/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..1826526e091b89c896e7099ccd891db79165e329 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/.nycrc @@ -0,0 +1,13 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "lines": 86, + "statements": 85.93, + "functions": 82.43, + "branches": 76.06, + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/has-tostringtag/CHANGELOG.md b/tools/ui/node_modules/has-tostringtag/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..eb186ec601ca337a3e77d372edbdc1d560cd4294 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/CHANGELOG.md @@ -0,0 +1,42 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v1.0.2](https://github.com/inspect-js/has-tostringtag/compare/v1.0.1...v1.0.2) - 2024-02-01 + +### Fixed + +- [Fix] move `has-symbols` back to prod deps [`#3`](https://github.com/inspect-js/has-tostringtag/issues/3) + +## [v1.0.1](https://github.com/inspect-js/has-tostringtag/compare/v1.0.0...v1.0.1) - 2024-02-01 + +### Commits + +- [patch] add types [`9276414`](https://github.com/inspect-js/has-tostringtag/commit/9276414b22fab3eeb234688841722c4be113201f) +- [meta] use `npmignore` to autogenerate an npmignore file [`5c0dcd1`](https://github.com/inspect-js/has-tostringtag/commit/5c0dcd1ff66419562a30d1fd88b966cc36bce5fc) +- [actions] reuse common workflows [`dee9509`](https://github.com/inspect-js/has-tostringtag/commit/dee950904ab5719b62cf8d73d2ac950b09093266) +- [actions] update codecov uploader [`b8cb3a0`](https://github.com/inspect-js/has-tostringtag/commit/b8cb3a0b8ffbb1593012c4c2daa45fb25642825d) +- [Tests] generate coverage [`be5b288`](https://github.com/inspect-js/has-tostringtag/commit/be5b28889e2735cdbcef387f84c2829995f2f05e) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `safe-publish-latest`, `tape` [`69a0827`](https://github.com/inspect-js/has-tostringtag/commit/69a0827974e9b877b2c75b70b057555da8f25a65) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `tape` [`4c9e210`](https://github.com/inspect-js/has-tostringtag/commit/4c9e210a5682f0557a3235d36b68ce809d7fb825) +- [actions] update rebase action to use reusable workflow [`ca8dcd3`](https://github.com/inspect-js/has-tostringtag/commit/ca8dcd3a6f3f5805d7e3fd461b654aedba0946e7) +- [Dev Deps] update `@ljharb/eslint-config`, `aud`, `npmignore`, `tape` [`07f3eaf`](https://github.com/inspect-js/has-tostringtag/commit/07f3eafa45dd98208c94479737da77f9a69b94c4) +- [Deps] update `has-symbols` [`999e009`](https://github.com/inspect-js/has-tostringtag/commit/999e0095a7d1749a58f55472ec8bf8108cdfdcf3) +- [Tests] remove staging tests since they fail on modern node [`9d9526b`](https://github.com/inspect-js/has-tostringtag/commit/9d9526b1dc1ca7f2292b52efda4c3d857b0e39bd) + +## v1.0.0 - 2021-08-05 + +### Commits + +- Tests [`6b6f573`](https://github.com/inspect-js/has-tostringtag/commit/6b6f5734dc2058badb300ff0783efdad95fe1a65) +- Initial commit [`2f8190e`](https://github.com/inspect-js/has-tostringtag/commit/2f8190e799fac32ba9b95a076c0255e01d7ce475) +- [meta] do not publish github action workflow files [`6e08cc4`](https://github.com/inspect-js/has-tostringtag/commit/6e08cc4e0fea7ec71ef66e70734b2af2c4a8b71b) +- readme [`94bed6c`](https://github.com/inspect-js/has-tostringtag/commit/94bed6c9560cbbfda034f8d6c260bb7b0db33c1a) +- npm init [`be67840`](https://github.com/inspect-js/has-tostringtag/commit/be67840ab92ee7adb98bcc65261975543f815fa5) +- Implementation [`c4914ec`](https://github.com/inspect-js/has-tostringtag/commit/c4914ecc51ddee692c85b471ae0a5d8123030fbf) +- [meta] use `auto-changelog` [`4aaf768`](https://github.com/inspect-js/has-tostringtag/commit/4aaf76895ae01d7b739f2b19f967ef2372506cd7) +- Only apps should have lockfiles [`bc4d99e`](https://github.com/inspect-js/has-tostringtag/commit/bc4d99e4bf494afbaa235c5f098df6e642edf724) +- [meta] add `safe-publish-latest` [`6523c05`](https://github.com/inspect-js/has-tostringtag/commit/6523c05c9b87140f3ae74c9daf91633dd9ff4e1f) diff --git a/tools/ui/node_modules/has-tostringtag/LICENSE b/tools/ui/node_modules/has-tostringtag/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..7948bc02a7937478ae009ff3796e76b25bdfbb08 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Inspect JS + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/has-tostringtag/README.md b/tools/ui/node_modules/has-tostringtag/README.md new file mode 100644 index 0000000000000000000000000000000000000000..67a5e929dfce41c47370c4141ed9fae8ba6aea21 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/README.md @@ -0,0 +1,46 @@ +# has-tostringtag [![Version Badge][2]][1] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![dependency status][5]][6] +[![dev dependency status][7]][8] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][11]][1] + +Determine if the JS environment has `Symbol.toStringTag` support. Supports spec, or shams. + +## Example + +```js +var hasSymbolToStringTag = require('has-tostringtag'); + +hasSymbolToStringTag() === true; // if the environment has native Symbol.toStringTag support. Not polyfillable, not forgeable. + +var hasSymbolToStringTagKinda = require('has-tostringtag/shams'); +hasSymbolToStringTagKinda() === true; // if the environment has a Symbol.toStringTag sham that mostly follows the spec. +``` + +## Supported Symbol shams + - get-own-property-symbols [npm](https://www.npmjs.com/package/get-own-property-symbols) | [github](https://github.com/WebReflection/get-own-property-symbols) + - core-js [npm](https://www.npmjs.com/package/core-js) | [github](https://github.com/zloirock/core-js) + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[1]: https://npmjs.org/package/has-tostringtag +[2]: https://versionbadg.es/inspect-js/has-tostringtag.svg +[5]: https://david-dm.org/inspect-js/has-tostringtag.svg +[6]: https://david-dm.org/inspect-js/has-tostringtag +[7]: https://david-dm.org/inspect-js/has-tostringtag/dev-status.svg +[8]: https://david-dm.org/inspect-js/has-tostringtag#info=devDependencies +[11]: https://nodei.co/npm/has-tostringtag.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/has-tostringtag.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/has-tostringtag.svg +[downloads-url]: https://npm-stat.com/charts.html?package=has-tostringtag +[codecov-image]: https://codecov.io/gh/inspect-js/has-tostringtag/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/inspect-js/has-tostringtag/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/has-tostringtag +[actions-url]: https://github.com/inspect-js/has-tostringtag/actions diff --git a/tools/ui/node_modules/has-tostringtag/index.d.ts b/tools/ui/node_modules/has-tostringtag/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..a61bc60a86c3c7149b6fcef29c4826d2ee404235 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/index.d.ts @@ -0,0 +1,3 @@ +declare function hasToStringTag(): boolean; + +export = hasToStringTag; diff --git a/tools/ui/node_modules/has-tostringtag/index.js b/tools/ui/node_modules/has-tostringtag/index.js new file mode 100644 index 0000000000000000000000000000000000000000..77bfa00702851e245eaca0b4bb197075e4afd9a9 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/index.js @@ -0,0 +1,8 @@ +'use strict'; + +var hasSymbols = require('has-symbols'); + +/** @type {import('.')} */ +module.exports = function hasToStringTag() { + return hasSymbols() && typeof Symbol.toStringTag === 'symbol'; +}; diff --git a/tools/ui/node_modules/has-tostringtag/package.json b/tools/ui/node_modules/has-tostringtag/package.json new file mode 100644 index 0000000000000000000000000000000000000000..e5b0300258950d1cd622fc5367ddf50717278ce0 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/package.json @@ -0,0 +1,108 @@ +{ + "name": "has-tostringtag", + "version": "1.0.2", + "author": { + "name": "Jordan Harband", + "email": "ljharb@gmail.com", + "url": "http://ljharb.codes" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + }, + "contributors": [ + { + "name": "Jordan Harband", + "email": "ljharb@gmail.com", + "url": "http://ljharb.codes" + } + ], + "description": "Determine if the JS environment has `Symbol.toStringTag` support. Supports spec, or shams.", + "license": "MIT", + "main": "index.js", + "types": "./index.d.ts", + "exports": { + ".": [ + { + "types": "./index.d.ts", + "default": "./index.js" + }, + "./index.js" + ], + "./shams": [ + { + "types": "./shams.d.ts", + "default": "./shams.js" + }, + "./shams.js" + ], + "./package.json": "./package.json" + }, + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublishOnly": "safe-publish-latest", + "prepublish": "not-in-publish || npm run prepublishOnly", + "pretest": "npm run --silent lint", + "test": "npm run tests-only", + "posttest": "aud --production", + "tests-only": "npm run test:stock && npm run test:shams", + "test:stock": "nyc node test", + "test:staging": "nyc node --harmony --es-staging test", + "test:shams": "npm run --silent test:shams:getownpropertysymbols && npm run --silent test:shams:corejs", + "test:shams:corejs": "nyc node test/shams/core-js.js", + "test:shams:getownpropertysymbols": "nyc node test/shams/get-own-property-symbols.js", + "lint": "eslint --ext=js,mjs .", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/inspect-js/has-tostringtag.git" + }, + "bugs": { + "url": "https://github.com/inspect-js/has-tostringtag/issues" + }, + "homepage": "https://github.com/inspect-js/has-tostringtag#readme", + "keywords": [ + "javascript", + "ecmascript", + "symbol", + "symbols", + "tostringtag", + "Symbol.toStringTag" + ], + "devDependencies": { + "@ljharb/eslint-config": "^21.1.0", + "@types/has-symbols": "^1.0.2", + "@types/tape": "^5.6.4", + "aud": "^2.0.4", + "auto-changelog": "^2.4.0", + "core-js": "^2.6.12", + "eslint": "=8.8.0", + "get-own-property-symbols": "^0.9.5", + "in-publish": "^2.0.1", + "npmignore": "^0.3.1", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "tape": "^5.7.4", + "typescript": "next" + }, + "engines": { + "node": ">= 0.4" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows" + ] + }, + "dependencies": { + "has-symbols": "^1.0.3" + } +} diff --git a/tools/ui/node_modules/has-tostringtag/shams.d.ts b/tools/ui/node_modules/has-tostringtag/shams.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ea4aeecfd04c4c0b3dc79389754968cf1e201c06 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/shams.d.ts @@ -0,0 +1,3 @@ +declare function hasToStringTagShams(): boolean; + +export = hasToStringTagShams; diff --git a/tools/ui/node_modules/has-tostringtag/shams.js b/tools/ui/node_modules/has-tostringtag/shams.js new file mode 100644 index 0000000000000000000000000000000000000000..809580dbd6a347bb63b22eb116a14e32bcd64cda --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/shams.js @@ -0,0 +1,8 @@ +'use strict'; + +var hasSymbols = require('has-symbols/shams'); + +/** @type {import('.')} */ +module.exports = function hasToStringTagShams() { + return hasSymbols() && !!Symbol.toStringTag; +}; diff --git a/tools/ui/node_modules/has-tostringtag/test/index.js b/tools/ui/node_modules/has-tostringtag/test/index.js new file mode 100644 index 0000000000000000000000000000000000000000..0679afdfa78bffebe91fda3023491bba375b53a6 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/test/index.js @@ -0,0 +1,21 @@ +'use strict'; + +var test = require('tape'); +var hasSymbolToStringTag = require('../'); +var runSymbolTests = require('./tests'); + +test('interface', function (t) { + t.equal(typeof hasSymbolToStringTag, 'function', 'is a function'); + t.equal(typeof hasSymbolToStringTag(), 'boolean', 'returns a boolean'); + t.end(); +}); + +test('Symbol.toStringTag exists', { skip: !hasSymbolToStringTag() }, function (t) { + runSymbolTests(t); + t.end(); +}); + +test('Symbol.toStringTag does not exist', { skip: hasSymbolToStringTag() }, function (t) { + t.equal(typeof Symbol === 'undefined' ? 'undefined' : typeof Symbol.toStringTag, 'undefined', 'global Symbol.toStringTag is undefined'); + t.end(); +}); diff --git a/tools/ui/node_modules/has-tostringtag/test/shams/core-js.js b/tools/ui/node_modules/has-tostringtag/test/shams/core-js.js new file mode 100644 index 0000000000000000000000000000000000000000..7ab214da3433e437bbd54ce422e389e88c01c1f7 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/test/shams/core-js.js @@ -0,0 +1,31 @@ +'use strict'; + +var test = require('tape'); + +if (typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol') { + test('has native Symbol.toStringTag support', function (t) { + t.equal(typeof Symbol, 'function'); + t.equal(typeof Symbol.toStringTag, 'symbol'); + t.end(); + }); + // @ts-expect-error CJS has top-level return + return; +} + +var hasSymbolToStringTag = require('../../shams'); + +test('polyfilled Symbols', function (t) { + /* eslint-disable global-require */ + t.equal(hasSymbolToStringTag(), false, 'hasSymbolToStringTag is false before polyfilling'); + // @ts-expect-error no types defined + require('core-js/fn/symbol'); + // @ts-expect-error no types defined + require('core-js/fn/symbol/to-string-tag'); + + require('../tests')(t); + + var hasToStringTagAfter = hasSymbolToStringTag(); + t.equal(hasToStringTagAfter, true, 'hasSymbolToStringTag is true after polyfilling'); + /* eslint-enable global-require */ + t.end(); +}); diff --git a/tools/ui/node_modules/has-tostringtag/test/shams/get-own-property-symbols.js b/tools/ui/node_modules/has-tostringtag/test/shams/get-own-property-symbols.js new file mode 100644 index 0000000000000000000000000000000000000000..c8af44c522e5067c08511d5171f7e037f615e3d2 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/test/shams/get-own-property-symbols.js @@ -0,0 +1,30 @@ +'use strict'; + +var test = require('tape'); + +if (typeof Symbol === 'function' && typeof Symbol() === 'symbol') { + test('has native Symbol support', function (t) { + t.equal(typeof Symbol, 'function'); + t.equal(typeof Symbol(), 'symbol'); + t.end(); + }); + // @ts-expect-error CJS has top-level return + return; +} + +var hasSymbolToStringTag = require('../../shams'); + +test('polyfilled Symbols', function (t) { + /* eslint-disable global-require */ + t.equal(hasSymbolToStringTag(), false, 'hasSymbolToStringTag is false before polyfilling'); + + // @ts-expect-error no types defined + require('get-own-property-symbols'); + + require('../tests')(t); + + var hasToStringTagAfter = hasSymbolToStringTag(); + t.equal(hasToStringTagAfter, true, 'hasSymbolToStringTag is true after polyfilling'); + /* eslint-enable global-require */ + t.end(); +}); diff --git a/tools/ui/node_modules/has-tostringtag/test/tests.js b/tools/ui/node_modules/has-tostringtag/test/tests.js new file mode 100644 index 0000000000000000000000000000000000000000..2aa0d48877e45a58bf4b421ff7a110f529dbd0a0 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/test/tests.js @@ -0,0 +1,15 @@ +'use strict'; + +// eslint-disable-next-line consistent-return +module.exports = /** @type {(t: import('tape').Test) => void | false} */ function runSymbolTests(t) { + t.equal(typeof Symbol, 'function', 'global Symbol is a function'); + t.ok(Symbol.toStringTag, 'Symbol.toStringTag exists'); + + if (typeof Symbol !== 'function' || !Symbol.toStringTag) { return false; } + + /** @type {{ [Symbol.toStringTag]?: 'test'}} */ + var obj = {}; + obj[Symbol.toStringTag] = 'test'; + + t.equal(Object.prototype.toString.call(obj), '[object test]'); +}; diff --git a/tools/ui/node_modules/has-tostringtag/tsconfig.json b/tools/ui/node_modules/has-tostringtag/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..2002ce5a53532769b9b5bc561dac11518c384d13 --- /dev/null +++ b/tools/ui/node_modules/has-tostringtag/tsconfig.json @@ -0,0 +1,49 @@ +{ + "compilerOptions": { + /* Visit https://aka.ms/tsconfig to read more about this file */ + + /* Projects */ + + /* Language and Environment */ + "target": "ESNext", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */ + // "lib": [], /* Specify a set of bundled library declaration files that describe the target runtime environment. */ + // "noLib": true, /* Disable including any library files, including the default lib.d.ts. */ + "useDefineForClassFields": true, /* Emit ECMAScript-standard-compliant class fields. */ + // "moduleDetection": "auto", /* Control what method is used to detect module-format JS files. */ + + /* Modules */ + "module": "commonjs", /* Specify what module code is generated. */ + // "rootDir": "./", /* Specify the root folder within your source files. */ + // "moduleResolution": "node10", /* Specify how TypeScript looks up a file from a given module specifier. */ + // "baseUrl": "./", /* Specify the base directory to resolve non-relative module names. */ + // "paths": {}, /* Specify a set of entries that re-map imports to additional lookup locations. */ + // "rootDirs": [], /* Allow multiple folders to be treated as one when resolving modules. */ + "typeRoots": ["types"], /* Specify multiple folders that act like './node_modules/@types'. */ + "resolveJsonModule": true, /* Enable importing .json files. */ + // "allowArbitraryExtensions": true, /* Enable importing files with any extension, provided a declaration file is present. */ + + /* JavaScript Support */ + "allowJs": true, /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */ + "checkJs": true, /* Enable error reporting in type-checked JavaScript files. */ + "maxNodeModuleJsDepth": 0, /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */ + + /* Emit */ + "declaration": true, /* Generate .d.ts files from TypeScript and JavaScript files in your project. */ + "declarationMap": true, /* Create sourcemaps for d.ts files. */ + "noEmit": true, /* Disable emitting files from a compilation. */ + + /* Interop Constraints */ + "allowSyntheticDefaultImports": true, /* Allow 'import x from y' when a module doesn't have a default export. */ + "esModuleInterop": true, /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */ + "forceConsistentCasingInFileNames": true, /* Ensure that casing is correct in imports. */ + + /* Type Checking */ + "strict": true, /* Enable all strict type-checking options. */ + + /* Completeness */ + //"skipLibCheck": true /* Skip type checking all .d.ts files. */ + }, + "exclude": [ + "coverage" + ] +} diff --git a/tools/ui/node_modules/hasown/.github/FUNDING.yml b/tools/ui/node_modules/hasown/.github/FUNDING.yml new file mode 100644 index 0000000000000000000000000000000000000000..d68c8b716ff04186cd4c0ed8f85af474cfbfbc6a --- /dev/null +++ b/tools/ui/node_modules/hasown/.github/FUNDING.yml @@ -0,0 +1,12 @@ +# These are supported funding model platforms + +github: [ljharb] +patreon: # Replace with a single Patreon username +open_collective: # Replace with a single Open Collective username +ko_fi: # Replace with a single Ko-fi username +tidelift: npm/hasown +community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry +liberapay: # Replace with a single Liberapay username +issuehunt: # Replace with a single IssueHunt username +otechie: # Replace with a single Otechie username +custom: # Replace with a single custom sponsorship URL diff --git a/tools/ui/node_modules/hasown/.nycrc b/tools/ui/node_modules/hasown/.nycrc new file mode 100644 index 0000000000000000000000000000000000000000..1826526e091b89c896e7099ccd891db79165e329 --- /dev/null +++ b/tools/ui/node_modules/hasown/.nycrc @@ -0,0 +1,13 @@ +{ + "all": true, + "check-coverage": false, + "reporter": ["text-summary", "text", "html", "json"], + "lines": 86, + "statements": 85.93, + "functions": 82.43, + "branches": 76.06, + "exclude": [ + "coverage", + "test" + ] +} diff --git a/tools/ui/node_modules/hasown/CHANGELOG.md b/tools/ui/node_modules/hasown/CHANGELOG.md new file mode 100644 index 0000000000000000000000000000000000000000..90a43dc309b047ad27d1efee6c1f08c6d522583f --- /dev/null +++ b/tools/ui/node_modules/hasown/CHANGELOG.md @@ -0,0 +1,58 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) +and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). + +## [v2.0.4](https://github.com/inspect-js/hasOwn/compare/v2.0.3...v2.0.4) - 2026-05-28 + +### Commits + +- [types] drop the dead key-narrowing overload [`fdab00e`](https://github.com/inspect-js/hasOwn/commit/fdab00e2703e65411424e19bf86a7e72a8f10da9) +- [Dev Deps] update `@ljharb/eslint-config`, `auto-changelog`, `eslint` [`91f6247`](https://github.com/inspect-js/hasOwn/commit/91f624768dd0f7db0d019b89d4d86bd66e20ec30) + +## [v2.0.3](https://github.com/inspect-js/hasOwn/compare/v2.0.2...v2.0.3) - 2026-04-17 + +### Commits + +- [actions] update workflows [`fb837b8`](https://github.com/inspect-js/hasOwn/commit/fb837b849bcdb8416fdc8fd344edfacd5574696c) +- [Dev Deps] update `@arethetypeswrong/cli`, `@ljharb/eslint-config`, `@ljharb/tsconfig`, `@types/tape`, `auto-changelog`, `eslint`, `mock-property`, `npmignore`, `tape` [`f4b279b`](https://github.com/inspect-js/hasOwn/commit/f4b279bd682be34b3f0ede2a58d4e8acb58d6d47) +- [Dev Deps] update `eslint`, `@ljharb/eslint-config`; migrate to flat config [`7e415ce`](https://github.com/inspect-js/hasOwn/commit/7e415cee55ebf43b3c34d7fd86db73a9928b05f7) +- [Dev Deps] update `eslint` [`ef313da`](https://github.com/inspect-js/hasOwn/commit/ef313da342d33b60e23e738b9f5a86f6065f39ef) +- [meta] use `npm audit` instead of `aud` [`d5c6d4d`](https://github.com/inspect-js/hasOwn/commit/d5c6d4d7a19c6ca4f14ac173b30d8bf25abcabee) +- [types] add overload that narrows the key [`cc03a09`](https://github.com/inspect-js/hasOwn/commit/cc03a097e9402fb8b86d413050e67f790dd6c8c5) + +## [v2.0.2](https://github.com/inspect-js/hasOwn/compare/v2.0.1...v2.0.2) - 2024-03-10 + +### Commits + +- [types] use shared config [`68e9d4d`](https://github.com/inspect-js/hasOwn/commit/68e9d4dab6facb4f05f02c6baea94a3f2a4e44b2) +- [actions] remove redundant finisher; use reusable workflow [`241a68e`](https://github.com/inspect-js/hasOwn/commit/241a68e13ea1fe52bec5ba7f74144befc31fae7b) +- [Tests] increase coverage [`4125c0d`](https://github.com/inspect-js/hasOwn/commit/4125c0d6121db56ae30e38346dfb0c000b04f0a7) +- [Tests] skip `npm ls` in old node due to TS [`01b9282`](https://github.com/inspect-js/hasOwn/commit/01b92822f9971dea031eafdd14767df41d61c202) +- [types] improve predicate type [`d340f85`](https://github.com/inspect-js/hasOwn/commit/d340f85ce02e286ef61096cbbb6697081d40a12b) +- [Dev Deps] update `tape` [`70089fc`](https://github.com/inspect-js/hasOwn/commit/70089fcf544e64acc024cbe60f5a9b00acad86de) +- [Tests] use `@arethetypeswrong/cli` [`50b272c`](https://github.com/inspect-js/hasOwn/commit/50b272c829f40d053a3dd91c9796e0ac0b2af084) + +## [v2.0.1](https://github.com/inspect-js/hasOwn/compare/v2.0.0...v2.0.1) - 2024-02-10 + +### Commits + +- [types] use a handwritten d.ts file; fix exported type [`012b989`](https://github.com/inspect-js/hasOwn/commit/012b9898ccf91dc441e2ebf594ff70270a5fda58) +- [Dev Deps] update `@types/function-bind`, `@types/mock-property`, `@types/tape`, `aud`, `mock-property`, `npmignore`, `tape`, `typescript` [`977a56f`](https://github.com/inspect-js/hasOwn/commit/977a56f51a1f8b20566f3c471612137894644025) +- [meta] add `sideEffects` flag [`3a60b7b`](https://github.com/inspect-js/hasOwn/commit/3a60b7bf42fccd8c605e5f145a6fcc83b13cb46f) + +## [v2.0.0](https://github.com/inspect-js/hasOwn/compare/v1.0.1...v2.0.0) - 2023-10-19 + +### Commits + +- revamped implementation, tests, readme [`72bf8b3`](https://github.com/inspect-js/hasOwn/commit/72bf8b338e77a638f0a290c63ffaed18339c36b4) +- [meta] revamp package.json [`079775f`](https://github.com/inspect-js/hasOwn/commit/079775fb1ec72c1c6334069593617a0be3847458) +- Only apps should have lockfiles [`6640e23`](https://github.com/inspect-js/hasOwn/commit/6640e233d1bb8b65260880f90787637db157d215) + +## v1.0.1 - 2023-10-10 + +### Commits + +- Initial commit [`8dbfde6`](https://github.com/inspect-js/hasOwn/commit/8dbfde6e8fb0ebb076fab38d138f2984eb340a62) diff --git a/tools/ui/node_modules/hasown/LICENSE b/tools/ui/node_modules/hasown/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..0314929078de8a733a0af9c8ba5bc00aca094cc9 --- /dev/null +++ b/tools/ui/node_modules/hasown/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) Jordan Harband and contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/tools/ui/node_modules/hasown/README.md b/tools/ui/node_modules/hasown/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f759b8a8396e3993fb7901d7551d38ee2a786b31 --- /dev/null +++ b/tools/ui/node_modules/hasown/README.md @@ -0,0 +1,40 @@ +# hasown [![Version Badge][npm-version-svg]][package-url] + +[![github actions][actions-image]][actions-url] +[![coverage][codecov-image]][codecov-url] +[![License][license-image]][license-url] +[![Downloads][downloads-image]][downloads-url] + +[![npm badge][npm-badge-png]][package-url] + +A robust, ES3 compatible, "has own property" predicate. + +## Example + +```js +const assert = require('assert'); +const hasOwn = require('hasown'); + +assert.equal(hasOwn({}, 'toString'), false); +assert.equal(hasOwn([], 'length'), true); +assert.equal(hasOwn({ a: 42 }, 'a'), true); +``` + +## Tests +Simply clone the repo, `npm install`, and run `npm test` + +[package-url]: https://npmjs.org/package/hasown +[npm-version-svg]: https://versionbadg.es/inspect-js/hasown.svg +[deps-svg]: https://david-dm.org/inspect-js/hasOwn.svg +[deps-url]: https://david-dm.org/inspect-js/hasOwn +[dev-deps-svg]: https://david-dm.org/inspect-js/hasOwn/dev-status.svg +[dev-deps-url]: https://david-dm.org/inspect-js/hasOwn#info=devDependencies +[npm-badge-png]: https://nodei.co/npm/hasown.png?downloads=true&stars=true +[license-image]: https://img.shields.io/npm/l/hasown.svg +[license-url]: LICENSE +[downloads-image]: https://img.shields.io/npm/dm/hasown.svg +[downloads-url]: https://npm-stat.com/charts.html?package=hasown +[codecov-image]: https://codecov.io/gh/inspect-js/hasOwn/branch/main/graphs/badge.svg +[codecov-url]: https://app.codecov.io/gh/inspect-js/hasOwn/ +[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/inspect-js/hasOwn +[actions-url]: https://github.com/inspect-js/hasOwn/actions diff --git a/tools/ui/node_modules/hasown/eslint.config.mjs b/tools/ui/node_modules/hasown/eslint.config.mjs new file mode 100644 index 0000000000000000000000000000000000000000..3d634a0969b313e68694b29530cd777f1d0616b2 --- /dev/null +++ b/tools/ui/node_modules/hasown/eslint.config.mjs @@ -0,0 +1,6 @@ +import ljharbConfig from '@ljharb/eslint-config/flat'; + +export default [ + ...ljharbConfig, + { rules: { 'no-extra-parens': 'off' } }, +]; diff --git a/tools/ui/node_modules/hasown/index.d.ts b/tools/ui/node_modules/hasown/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..aafdf3b2b8f0ef01aa1b3e44596560eee3f38ff7 --- /dev/null +++ b/tools/ui/node_modules/hasown/index.d.ts @@ -0,0 +1,3 @@ +declare function hasOwn(o: O, p: K): o is O & Record; + +export = hasOwn; diff --git a/tools/ui/node_modules/hasown/index.js b/tools/ui/node_modules/hasown/index.js new file mode 100644 index 0000000000000000000000000000000000000000..34e60591349679d8cbdb1033a60eb5d171d7637e --- /dev/null +++ b/tools/ui/node_modules/hasown/index.js @@ -0,0 +1,8 @@ +'use strict'; + +var call = Function.prototype.call; +var $hasOwn = Object.prototype.hasOwnProperty; +var bind = require('function-bind'); + +/** @type {import('.')} */ +module.exports = bind.call(call, $hasOwn); diff --git a/tools/ui/node_modules/hasown/package.json b/tools/ui/node_modules/hasown/package.json new file mode 100644 index 0000000000000000000000000000000000000000..fb86cc3743bf6d1bc3ef39a0e980878b6bd07aa3 --- /dev/null +++ b/tools/ui/node_modules/hasown/package.json @@ -0,0 +1,91 @@ +{ + "name": "hasown", + "version": "2.0.4", + "description": "A robust, ES3 compatible, \"has own property\" predicate.", + "main": "index.js", + "exports": { + ".": "./index.js", + "./package.json": "./package.json" + }, + "types": "index.d.ts", + "sideEffects": false, + "scripts": { + "prepack": "npmignore --auto --commentLines=autogenerated", + "prepublish": "not-in-publish || npm run prepublishOnly", + "prepublishOnly": "safe-publish-latest", + "prelint": "evalmd README.md", + "lint": "eslint .", + "postlint": "npm run tsc", + "pretest": "npm run lint", + "tsc": "tsc -p .", + "posttsc": "attw -P", + "tests-only": "nyc tape 'test/**/*.js'", + "test": "npm run tests-only", + "posttest": "npx npm@\">= 10.2\" audit --production", + "version": "auto-changelog && git add CHANGELOG.md", + "postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\"" + }, + "repository": { + "type": "git", + "url": "git+https://github.com/inspect-js/hasOwn.git" + }, + "keywords": [ + "has", + "hasOwnProperty", + "hasOwn", + "has-own", + "own", + "has", + "property", + "in", + "javascript", + "ecmascript" + ], + "author": "Jordan Harband ", + "license": "MIT", + "bugs": { + "url": "https://github.com/inspect-js/hasOwn/issues" + }, + "homepage": "https://github.com/inspect-js/hasOwn#readme", + "dependencies": { + "function-bind": "^1.1.2" + }, + "devDependencies": { + "@arethetypeswrong/cli": "^0.18.2", + "@ljharb/eslint-config": "^22.2.3", + "@ljharb/tsconfig": "^0.3.2", + "@types/function-bind": "^1.1.10", + "@types/tape": "^5.8.1", + "auto-changelog": "^2.5.1", + "eslint": "^10.4.0", + "evalmd": "^0.0.19", + "in-publish": "^2.0.1", + "jiti": "^0.0.0", + "mock-property": "^1.1.0", + "npmignore": "^0.3.5", + "nyc": "^10.3.2", + "safe-publish-latest": "^2.0.0", + "tape": "^5.9.0", + "typescript": "next" + }, + "engines": { + "node": ">= 0.4" + }, + "testling": { + "files": "test/index.js" + }, + "auto-changelog": { + "output": "CHANGELOG.md", + "template": "keepachangelog", + "unreleased": false, + "commitLimit": false, + "backfillLimit": false, + "hideCredit": true + }, + "publishConfig": { + "ignore": [ + ".github/workflows", + "test" + ] + } +} diff --git a/tools/ui/node_modules/hasown/tsconfig.json b/tools/ui/node_modules/hasown/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..0930c565850326810b8efe09ca98895aeffd8f21 --- /dev/null +++ b/tools/ui/node_modules/hasown/tsconfig.json @@ -0,0 +1,6 @@ +{ + "extends": "@ljharb/tsconfig", + "exclude": [ + "coverage", + ], +} diff --git a/tools/ui/node_modules/hast-util-from-dom/index.d.ts b/tools/ui/node_modules/hast-util-from-dom/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..ddb942eba009cdfe30b93b95dc4cbb7f8666e2ea --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-dom/index.d.ts @@ -0,0 +1,4 @@ +export { fromDom } from "./lib/index.js"; +export type AfterTransform = import("./lib/index.js").AfterTransform; +export type Options = import("./lib/index.js").Options; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/hast-util-from-dom/index.d.ts.map b/tools/ui/node_modules/hast-util-from-dom/index.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..a00f77b5ff0881016fb94a816fde5008b1e62739 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-dom/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":";6BACa,OAAO,gBAAgB,EAAE,cAAc;sBACvC,OAAO,gBAAgB,EAAE,OAAO"} \ No newline at end of file diff --git a/tools/ui/node_modules/hast-util-from-dom/index.js b/tools/ui/node_modules/hast-util-from-dom/index.js new file mode 100644 index 0000000000000000000000000000000000000000..eac865a6bb603ef74dac081ae10e294f778b4035 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-dom/index.js @@ -0,0 +1,6 @@ +/** + * @typedef {import('./lib/index.js').AfterTransform} AfterTransform + * @typedef {import('./lib/index.js').Options} Options + */ + +export {fromDom} from './lib/index.js' diff --git a/tools/ui/node_modules/hast-util-from-dom/lib/index.d.ts b/tools/ui/node_modules/hast-util-from-dom/lib/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2abf1f1b80549f55e5285a7ad0e72efd1ada34c3 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-dom/lib/index.d.ts @@ -0,0 +1,26 @@ +/** + * Transform a DOM tree to a hast tree. + * + * @param {Node} tree + * DOM tree to transform. + * @param {Options | null | undefined} [options] + * Configuration (optional). + * @returns {HastNodes} + * Equivalent hast node. + */ +export function fromDom(tree: Node, options?: Options | null | undefined): HastNodes; +/** + * Callback called when each node is transformed. + */ +export type AfterTransform = (domNode: Node, hastNode: HastNodes) => undefined | void; +/** + * Configuration. + */ +export type Options = { + /** + * Callback called when each node is transformed (optional). + */ + afterTransform?: AfterTransform | null | undefined; +}; +import type { Nodes as HastNodes } from 'hast'; +//# sourceMappingURL=index.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/hast-util-from-dom/lib/index.d.ts.map b/tools/ui/node_modules/hast-util-from-dom/lib/index.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..0b512f39da54cf9852a3d14afebc0a4b756f1aac --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-dom/lib/index.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAiCA;;;;;;;;;GASG;AACH,8BAPW,IAAI,YAEJ,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,SAAS,CAKrB;;;;uCA9BU,IAAI,YAEJ,SAAS,KAEP,SAAS,GAAG,IAAI;;;;;;;;qBAOf,cAAc,GAAG,IAAI,GAAG,SAAS;;wCAjBrC,MAAM"} \ No newline at end of file diff --git a/tools/ui/node_modules/hast-util-from-dom/lib/index.js b/tools/ui/node_modules/hast-util-from-dom/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..1ca73a79bfde44fd0a236286d8525fe3a9a09740 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-dom/lib/index.js @@ -0,0 +1,222 @@ +/** + * @import { + * Comment as HastComment, + * Doctype as HastDoctype, + * Element as HastElement, + * Nodes as HastNodes, + * RootContent as HastRootContent, + * Root as HastRoot, + * Text as HastText, + * } from 'hast' + */ + +/** + * @callback AfterTransform + * Callback called when each node is transformed. + * @param {Node} domNode + * DOM node that was handled. + * @param {HastNodes} hastNode + * Corresponding hast node. + * @returns {undefined | void} + * Nothing. + * + * Note: `void` included until TS infers `undefined` nicely. + * + * @typedef Options + * Configuration. + * @property {AfterTransform | null | undefined} [afterTransform] + * Callback called when each node is transformed (optional). + */ + +import {h, s} from 'hastscript' +import {webNamespaces} from 'web-namespaces' + +/** + * Transform a DOM tree to a hast tree. + * + * @param {Node} tree + * DOM tree to transform. + * @param {Options | null | undefined} [options] + * Configuration (optional). + * @returns {HastNodes} + * Equivalent hast node. + */ +export function fromDom(tree, options) { + return transform(tree, options || {}) || {type: 'root', children: []} +} + +/** + * @param {Node} node + * DOM node to transform. + * @param {Options} options + * Configuration. + * @returns {HastNodes | undefined} + * Equivalent hast node. + * + * Note that certain legacy DOM nodes (i.e., Attr nodes (2), CDATA, processing instructions) + */ +function transform(node, options) { + const transformed = one(node, options) + if (transformed && options.afterTransform) + options.afterTransform(node, transformed) + return transformed +} + +/** + * @param {Node} node + * DOM node to transform. + * @param {Options} options + * Configuration. + * @returns {HastNodes | undefined} + * Equivalent hast node. + */ +function one(node, options) { + switch (node.nodeType) { + case 1 /* Element */: { + const domNode = /** @type {Element} */ (node) + return element(domNode, options) + } + + // Ignore: Attr (2). + + case 3 /* Text */: { + const domNode = /** @type {Text} */ (node) + return text(domNode) + } + + // Ignore: CDATA (4). + // Removed: Entity reference (5) + // Removed: Entity (6) + // Ignore: Processing instruction (7). + + case 8 /* Comment */: { + const domNode = /** @type {Comment} */ (node) + return comment(domNode) + } + + case 9 /* Document */: { + const domNode = /** @type {Document} */ (node) + return root(domNode, options) + } + + case 10 /* Document type */: { + return doctype() + } + + case 11 /* Document fragment */: { + const domNode = /** @type {DocumentFragment} */ (node) + return root(domNode, options) + } + + default: { + return undefined + } + } +} + +/** + * Transform a document. + * + * @param {Document | DocumentFragment} node + * DOM node to transform. + * @param {Options} options + * Configuration. + * @returns {HastRoot} + * Equivalent hast node. + */ +function root(node, options) { + return {type: 'root', children: all(node, options)} +} + +/** + * Transform a doctype. + * + * @returns {HastDoctype} + * Equivalent hast node. + */ +function doctype() { + return {type: 'doctype'} +} + +/** + * Transform a text. + * + * @param {Text} node + * DOM node to transform. + * @returns {HastText} + * Equivalent hast node. + */ +function text(node) { + return {type: 'text', value: node.nodeValue || ''} +} + +/** + * Transform a comment. + * + * @param {Comment} node + * DOM node to transform. + * @returns {HastComment} + * Equivalent hast node. + */ +function comment(node) { + return {type: 'comment', value: node.nodeValue || ''} +} + +/** + * Transform an element. + * + * @param {Element} node + * DOM node to transform. + * @param {Options} options + * Configuration. + * @returns {HastElement} + * Equivalent hast node. + */ +function element(node, options) { + const space = node.namespaceURI + const x = space === webNamespaces.svg ? s : h + const tagName = + space === webNamespaces.html ? node.tagName.toLowerCase() : node.tagName + /** @type {DocumentFragment | Element} */ + const content = + // @ts-expect-error: DOM types are wrong, content can exist. + space === webNamespaces.html && tagName === 'template' ? node.content : node + const attributes = node.getAttributeNames() + /** @type {Record} */ + const properties = {} + let index = -1 + + while (++index < attributes.length) { + properties[attributes[index]] = node.getAttribute(attributes[index]) || '' + } + + return x(tagName, properties, all(content, options)) +} + +/** + * Transform child nodes in a parent. + * + * @param {Document | DocumentFragment | Element} node + * DOM node to transform. + * @param {Options} options + * Configuration. + * @returns {Array} + * Equivalent hast nodes. + */ +function all(node, options) { + const nodes = node.childNodes + /** @type {Array} */ + const children = [] + let index = -1 + + while (++index < nodes.length) { + const child = transform(nodes[index], options) + + if (child !== undefined) { + // @ts-expect-error Assume no document inside document. + children.push(child) + } + } + + return children +} diff --git a/tools/ui/node_modules/hast-util-from-dom/license b/tools/ui/node_modules/hast-util-from-dom/license new file mode 100644 index 0000000000000000000000000000000000000000..b6b35a5e74afa81205fc116da399f7a2c31d1ce8 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-dom/license @@ -0,0 +1,15 @@ +(ISC License) + +Copyright (c) Keith McKnight + +Permission to use, copy, modify, and/or distribute this software for any purpose +with or without fee is hereby granted, provided that the above copyright notice +and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS +OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF +THIS SOFTWARE. diff --git a/tools/ui/node_modules/hast-util-from-dom/package.json b/tools/ui/node_modules/hast-util-from-dom/package.json new file mode 100644 index 0000000000000000000000000000000000000000..d9482622845716585c7d9e229b73fa84cbd9b35d --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-dom/package.json @@ -0,0 +1,88 @@ +{ + "author": "Keith McKnight (https://keith.mcknig.ht)", + "bugs": "https://github.com/syntax-tree/hast-util-from-dom/issues", + "contributors": [ + "Keith McKnight (https://keith.mcknig.ht)", + "Titus Wormer (https://wooorm.com)" + ], + "dependencies": { + "@types/hast": "^3.0.0", + "hastscript": "^9.0.0", + "web-namespaces": "^2.0.0" + }, + "description": "hast utility to create a tree from the DOM", + "devDependencies": { + "@types/jsdom": "^21.0.0", + "@types/node": "^22.0.0", + "c8": "^10.0.0", + "jsdom": "^25.0.0", + "prettier": "^3.0.0", + "remark-cli": "^12.0.0", + "remark-preset-wooorm": "^10.0.0", + "type-coverage": "^2.0.0", + "typescript": "^5.0.0", + "xo": "^0.59.0" + }, + "exports": "./index.js", + "files": [ + "index.d.ts.map", + "index.d.ts", + "index.js", + "lib/" + ], + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + }, + "keywords": [ + "dom", + "hast-util", + "hast", + "html", + "rehype", + "unist", + "utility", + "util" + ], + "license": "ISC", + "name": "hast-util-from-dom", + "prettier": { + "bracketSpacing": false, + "semi": false, + "singleQuote": true, + "tabWidth": 2, + "trailingComma": "none", + "useTabs": false + }, + "remarkConfig": { + "plugins": [ + "remark-preset-wooorm" + ] + }, + "repository": "syntax-tree/hast-util-from-dom", + "scripts": { + "build": "tsc --build --clean && tsc --build && type-coverage", + "format": "remark --frail --quiet --output -- . && prettier --log-level warn --write -- . && xo --fix", + "test-api": "node --conditions development test/index.js", + "test-coverage": "c8 --100 --reporter lcov -- npm run test-api", + "test": "npm run build && npm run format && npm run test-coverage" + }, + "sideEffects": false, + "typeCoverage": { + "atLeast": 100, + "strict": true + }, + "type": "module", + "version": "5.0.1", + "xo": { + "overrides": [ + { + "files": "test/**/*.js", + "rules": { + "no-await-in-loop": "off" + } + } + ], + "prettier": true + } +} diff --git a/tools/ui/node_modules/hast-util-from-dom/readme.md b/tools/ui/node_modules/hast-util-from-dom/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..05801091f85f72c13764214c5d164271ceb63e7f --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-dom/readme.md @@ -0,0 +1,264 @@ +# hast-util-from-dom + +[![Build][build-badge]][build] +[![Coverage][coverage-badge]][coverage] +[![Downloads][downloads-badge]][downloads] +[![Size][size-badge]][size] +[![Sponsors][sponsors-badge]][collective] +[![Backers][backers-badge]][collective] +[![Chat][chat-badge]][chat] + +[hast][] utility to transform from a [DOM][] tree. + +## Contents + +* [What is this?](#what-is-this) +* [When should I use this?](#when-should-i-use-this) +* [Install](#install) +* [Use](#use) +* [API](#api) + * [`fromDom(tree, options?)`](#fromdomtree-options) + * [`AfterTransform`](#aftertransform) + * [`Options`](#options) +* [Types](#types) +* [Compatibility](#compatibility) +* [Security](#security) +* [Contribute](#contribute) +* [Related](#related) +* [License](#license) + +## What is this? + +This package is a utility that takes a DOM tree (from the actual DOM or from +things like [`jsdom`][jsdom]) as input and turns it into a [hast][] (HTML) +syntax tree. + +## When should I use this? + +You can use this project when you want to use hast in browsers. +This package is very small, but it does so by: + +* …not providing positional information +* …potentially yielding varying results in different (especially older) + browsers + +The hast utility [`hast-util-to-dom`][hast-util-to-dom] does the inverse of this +utility. +It turns hast into a DOM tree. + +The rehype plugin [`rehype-dom-parse`][rehype-dom-parse] wraps this utility to +parse HTML with DOM APIs. + +## Install + +This package is [ESM only][esm]. +In Node.js (version 16+), install with [npm][]: + +```sh +npm install hast-util-from-dom +``` + +In Deno with [`esm.sh`][esmsh]: + +```js +import {fromDom} from 'https://esm.sh/hast-util-from-dom@5' +``` + +In browsers with [`esm.sh`][esmsh]: + +```html + +``` + +## Use + +Say our page `example.html` looks as follows: + +```html + +Example + +
+

Hi

+

Hello, world!

+
+ +``` + +Now running `open example.html` prints the following to the console: + +```js +{type: "element", tagName: "main", properties: {}, children: Array} +``` + +## API + +This package exports the identifier [`fromDom`][api-from-dom]. +There is no default export. + +### `fromDom(tree, options?)` + +Transform a DOM tree to a hast tree. + +###### Parameters + +* `tree` ([`DomNode`][dom-node]) + — DOM tree to transform +* `options` ([`Options`][api-options], optional) + — configuration + +###### Returns + +Equivalent hast node ([`HastNode`][hast-node]). + +### `AfterTransform` + +Callback called when each node is transformed (TypeScript type). + +###### Parameters + +* `domNode` ([`DomNode`][dom-node]) + — DOM node that was handled +* `hastNode` ([`HastNode`][hast-node]) + — corresponding hast node + +###### Returns + +Nothing. + +### `Options` + +Configuration (TypeScript type). + +##### Fields + +* `afterTransform` ([`AfterTransform`][api-after-transform], optional) + — callback called when each node is transformed + +##### Returns + +[`HastNode`][hast-node]. + +## Types + +This package is fully typed with [TypeScript][]. +It exports the additional types [`AfterTransform`][api-after-transform] and +[`Options`][api-options]. + +## Compatibility + +Projects maintained by the unified collective are compatible with maintained +versions of Node.js. + +When we cut a new major release, we drop support for unmaintained versions of +Node. +This means we try to keep the current release line, `hast-util-from-dom@^5`, +compatible with Node.js 16. + +## Security + +Use of `hast-util-from-dom` itself is safe but see other utilities for more +information on potential security problems. + +## Contribute + +See [`contributing.md`][contributing] in [`syntax-tree/.github`][health] for +ways to get started. +See [`support.md`][support] for ways to get help. + +This project has a [code of conduct][coc]. +By interacting with this repository, organisation, or community you agree to +abide by its terms. + +## Related + +* [`hast-util-from-html`][hast-util-from-html] + — parse hast from a string of HTML +* [`hast-util-sanitize`](https://github.com/syntax-tree/hast-util-sanitize) + — sanitize hast nodes +* [`hast-util-to-html`](https://github.com/syntax-tree/hast-util-to-html) + — serialize hast as HTML +* [`hast-util-to-dom`](https://github.com/syntax-tree/hast-util-to-dom) + — create DOM trees from hast + +## License + +[ISC][license] © [Keith McKnight][author] + + + +[build-badge]: https://github.com/syntax-tree/hast-util-from-dom/workflows/main/badge.svg + +[build]: https://github.com/syntax-tree/hast-util-from-dom/actions + +[coverage-badge]: https://img.shields.io/codecov/c/github/syntax-tree/hast-util-from-dom.svg + +[coverage]: https://codecov.io/github/syntax-tree/hast-util-from-dom + +[downloads-badge]: https://img.shields.io/npm/dm/hast-util-from-dom.svg + +[downloads]: https://www.npmjs.com/package/hast-util-from-dom + +[size-badge]: https://img.shields.io/badge/dynamic/json?label=minzipped%20size&query=$.size.compressedSize&url=https://deno.bundlejs.com/?q=hast-util-from-dom + +[size]: https://bundlejs.com/?q=hast-util-from-dom + +[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg + +[backers-badge]: https://opencollective.com/unified/backers/badge.svg + +[collective]: https://opencollective.com/unified + +[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg + +[chat]: https://github.com/syntax-tree/unist/discussions + +[npm]: https://docs.npmjs.com/cli/install + +[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c + +[esmsh]: https://esm.sh + +[typescript]: https://www.typescriptlang.org + +[license]: license + +[author]: https://keith.mcknig.ht + +[health]: https://github.com/syntax-tree/.github + +[contributing]: https://github.com/syntax-tree/.github/blob/main/contributing.md + +[support]: https://github.com/syntax-tree/.github/blob/main/support.md + +[coc]: https://github.com/syntax-tree/.github/blob/main/code-of-conduct.md + +[hast]: https://github.com/syntax-tree/hast + +[hast-node]: https://github.com/syntax-tree/hast#nodes + +[dom]: https://developer.mozilla.org/docs/Web/API/Document_Object_Model + +[dom-node]: https://developer.mozilla.org/docs/Web/API/Node + +[hast-util-from-html]: https://github.com/syntax-tree/hast-util-from-html + +[hast-util-to-dom]: https://github.com/syntax-tree/hast-util-to-dom + +[rehype-dom-parse]: https://github.com/rehypejs/rehype-dom/tree/main/packages/rehype-dom-parse + +[jsdom]: https://github.com/jsdom/jsdom + +[api-from-dom]: #fromdomtree-options + +[api-options]: #options + +[api-after-transform]: #aftertransform diff --git a/tools/ui/node_modules/hast-util-from-html-isomorphic/index.d.ts b/tools/ui/node_modules/hast-util-from-html-isomorphic/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..64ee442cea956b4facfae9c7d2424d959a666410 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html-isomorphic/index.d.ts @@ -0,0 +1,2 @@ +export { fromHtmlIsomorphic } from "./lib/index.js"; +export type Options = import('./lib/index.js').Options; diff --git a/tools/ui/node_modules/hast-util-from-html-isomorphic/index.js b/tools/ui/node_modules/hast-util-from-html-isomorphic/index.js new file mode 100644 index 0000000000000000000000000000000000000000..2f05f174bc810661e595bf554b6b5a26ce75ecea --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html-isomorphic/index.js @@ -0,0 +1,5 @@ +/** + * @typedef {import('./lib/index.js').Options} Options + */ + +export {fromHtmlIsomorphic} from './lib/index.js' diff --git a/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/browser.d.ts b/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/browser.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..af5f73694a721b20b80efacbaa8860097165df43 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/browser.d.ts @@ -0,0 +1,3 @@ +export function fromHtmlIsomorphic(value: string, options?: import("./index.js").Options | null | undefined): import("hast").Root; +export type Root = import('hast').Root; +export type FromHtmlIsomorphic = typeof import('./index.js').fromHtmlIsomorphic; diff --git a/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/browser.js b/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/browser.js new file mode 100644 index 0000000000000000000000000000000000000000..5690b535dacca6ef4d31d02996439da2d1e5660f --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/browser.js @@ -0,0 +1,30 @@ +/** + * @typedef {import('hast').Root} Root + * + * @typedef {typeof import('./index.js').fromHtmlIsomorphic} FromHtmlIsomorphic + */ + +import {fromDom} from 'hast-util-from-dom' + +const parser = new DOMParser() + +/** @type {FromHtmlIsomorphic} */ +export function fromHtmlIsomorphic(value, options) { + const node = options?.fragment + ? parseFragment(value) + : parser.parseFromString(value, 'text/html') + + return /** @type {Root} */ (fromDom(node)) +} + +/** + * Parse as a fragment. + * + * @param {string} value + * @returns {DocumentFragment} + */ +function parseFragment(value) { + const template = document.createElement('template') + template.innerHTML = value + return template.content +} diff --git a/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/index.d.ts b/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..c83859b7ffca3e3b4a31abe1b819c0b7399bcd17 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/index.d.ts @@ -0,0 +1,14 @@ +/** + * Turn HTML into a syntax tree, using browser APIs when available, so it has + * a smaller bundle size there. + * + * @param {string} value + * Serialized HTML to parse. + * @param {Options | null | undefined} [options] + * Configuration (optional). + * @returns {Root} + * Tree. + */ +export function fromHtmlIsomorphic(value: string, options?: Options | null | undefined): Root; +export type Root = import('hast').Root; +export type Options = Pick; diff --git a/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/index.js b/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/index.js new file mode 100644 index 0000000000000000000000000000000000000000..c2f68cdf005699adfd6e4fe6f1cbbe78ba598710 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html-isomorphic/lib/index.js @@ -0,0 +1,26 @@ +/** + * @typedef {import('hast').Root} Root + * + * @typedef {Pick} Options + */ + +import {fromHtml} from 'hast-util-from-html' +import {removePosition} from 'unist-util-remove-position' + +/** + * Turn HTML into a syntax tree, using browser APIs when available, so it has + * a smaller bundle size there. + * + * @param {string} value + * Serialized HTML to parse. + * @param {Options | null | undefined} [options] + * Configuration (optional). + * @returns {Root} + * Tree. + */ +export function fromHtmlIsomorphic(value, options) { + const tree = fromHtml(value, options) + removePosition(tree, {force: true}) + delete tree.data + return tree +} diff --git a/tools/ui/node_modules/hast-util-from-html-isomorphic/license b/tools/ui/node_modules/hast-util-from-html-isomorphic/license new file mode 100644 index 0000000000000000000000000000000000000000..63b0bcd8442407e7661d64301422652726926df7 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html-isomorphic/license @@ -0,0 +1,22 @@ +(The MIT License) + +Copyright (c) 2023 Remco Haszing + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/tools/ui/node_modules/hast-util-from-html-isomorphic/package.json b/tools/ui/node_modules/hast-util-from-html-isomorphic/package.json new file mode 100644 index 0000000000000000000000000000000000000000..80e3629279078f416a01b6d0a9638721ef3d5a4e --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html-isomorphic/package.json @@ -0,0 +1,100 @@ +{ + "name": "hast-util-from-html-isomorphic", + "version": "2.0.0", + "description": "hast utility that turns HTML into a syntax tree (while being small in browsers)", + "license": "MIT", + "keywords": [ + "unist", + "hast", + "hast-util", + "util", + "utility", + "html", + "parse", + "dom" + ], + "repository": "syntax-tree/hast-util-from-html-isomorphic", + "bugs": "https://github.com/syntax-tree/hast-util-from-html-isomorphic/issues", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + }, + "author": "Remco Haszing ", + "contributors": [ + "Remco Haszing " + ], + "sideEffects": false, + "type": "module", + "exports": { + ".": { + "deno": "./index.js", + "react-native": "./index.js", + "worker": "./index.js", + "browser": "./lib/browser.js", + "default": "./index.js" + } + }, + "files": [ + "lib/", + "index.d.ts", + "index.js" + ], + "dependencies": { + "@types/hast": "^3.0.0", + "hast-util-from-html": "^2.0.0", + "hast-util-from-dom": "^5.0.0", + "unist-util-remove-position": "^5.0.0" + }, + "devDependencies": { + "@types/jsdom": "^21.0.0", + "@types/node": "^20.0.0", + "c8": "^8.0.0", + "jsdom": "^22.0.0", + "prettier": "^3.0.0", + "remark-cli": "^11.0.0", + "remark-preset-wooorm": "^9.0.0", + "type-coverage": "^2.0.0", + "typescript": "^5.0.0", + "xo": "^0.55.0" + }, + "scripts": { + "prepack": "npm run build && npm run format", + "build": "tsc --build --clean && tsc --build && type-coverage", + "format": "remark . -qfo && prettier . -w --log-level warn && xo --fix", + "test-browser": "node --conditions development --conditions browser -r ./test/dom.cjs test/index.js", + "test-node": "node --conditions development test/index.js", + "test-worker": "node --conditions development --conditions worker test/index.js", + "test-api": "npm run test-browser && npm run test-node && npm run test-worker", + "test-coverage": "c8 --100 --reporter lcov npm run test-api", + "test": "npm run build && npm run format && npm run test-coverage" + }, + "prettier": { + "bracketSpacing": false, + "semi": false, + "singleQuote": true, + "tabWidth": 2, + "trailingComma": "none", + "useTabs": false + }, + "remarkConfig": { + "plugins": [ + "remark-preset-wooorm", + [ + "remark-lint-no-html", + false + ] + ] + }, + "typeCoverage": { + "atLeast": 100, + "detail": true, + "ignoreCatch": true, + "strict": true + }, + "xo": { + "env": [ + "browser" + ], + "prettier": true + } +} diff --git a/tools/ui/node_modules/hast-util-from-html-isomorphic/readme.md b/tools/ui/node_modules/hast-util-from-html-isomorphic/readme.md new file mode 100644 index 0000000000000000000000000000000000000000..f90f85b00a1e7655164d190b910c5d15ade94a02 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html-isomorphic/readme.md @@ -0,0 +1,301 @@ +# hast-util-from-html-isomorphic + +[![Build][build-badge]][build] +[![Coverage][coverage-badge]][coverage] +[![Downloads][downloads-badge]][downloads] +[![Size][size-badge]][size] +[![Sponsors][sponsors-badge]][collective] +[![Backers][backers-badge]][collective] +[![Chat][chat-badge]][chat] + +[hast][] utility that turns HTML into a syntax tree, using browser APIs +when available, so it has a smaller bundle size there. + +## Contents + +* [What is this?](#what-is-this) +* [When should I use this?](#when-should-i-use-this) +* [Install](#install) +* [Use](#use) +* [API](#api) + * [`fromHtmlIsomorphic(value[, options])`](#fromhtmlisomorphicvalue-options) + * [`Options`](#options) +* [Examples](#examples) + * [Example: fragment versus document](#example-fragment-versus-document) +* [Syntax](#syntax) +* [Types](#types) +* [Compatibility](#compatibility) +* [Security](#security) +* [Related](#related) +* [Contribute](#contribute) +* [License](#license) + +## What is this? + +This package is a utility that takes HTML input and turns it into a hast syntax +tree. + +In a browser, this uses [`hast-util-from-dom`][hast-util-from-dom], +otherwise it uses [`hast-util-from-html`][hast-util-from-html]. + +## When should I use this? + +If you want to get a syntax tree without positional info, and your code should +be isomorphic (it could run anywhere), as it results in a smaller bundle size. + +If you need positional information, use +[`hast-util-from-html`][hast-util-from-html]. + +If you don’t care about positional info and your code only runs in browsers, +use [`hast-util-from-dom`][hast-util-from-dom]. + +Finally you can use the utility [`hast-util-to-html`][hast-util-to-html], +or [`hast-util-to-dom`][hast-util-to-dom] with `.outerHTML`, to do the inverse +of this utility. +That turns hast into HTML. + +## Install + +This package is [ESM only][esm]. +In Node.js (version 16+), install with [npm][]: + +```sh +npm install hast-util-from-html-isomorphic +``` + +In Deno with [`esm.sh`][esmsh]: + +```js +import {fromHtmlIsomorphic} from 'https://esm.sh/hast-util-from-html-isomorphic@2' +``` + +In browsers with [`esm.sh`][esmsh]: + +```html + +``` + +## Use + +```js +import {fromHtmlIsomorphic} from 'hast-util-from-html-isomorphic' + +const tree = fromHtmlIsomorphic('

Hello, world!

', {fragment: true}) + +console.log(tree) +``` + +Yields (positional info and data omitted for brevity): + +```js +{ + type: 'root', + children: [ + { + type: 'element', + tagName: 'h1', + properties: {}, + children: [Array], + } + ] +} +``` + +## API + +This package exports the identifier +[`fromHtmlIsomorphic`][api-from-html-isomorphic]. +There is no default export. + +### `fromHtmlIsomorphic(value[, options])` + +Turn serialized HTML into a hast tree. + +###### Parameters + +* `value` (`string`) + — serialized HTML to parse +* `options` ([`Options`][api-options], optional) + — configuration + +###### Returns + +Tree ([`Root`][root]). + +### `Options` + +Configuration (TypeScript type). + +##### Fields + +###### `fragment` + +Whether to parse as a fragment (`boolean`, default: `false`). +The default is to expect a whole document. +In document mode, unopened `html`, `head`, and `body` elements are opened. + +## Examples + +### Example: fragment versus document + +The following example shows the difference between parsing as a document and +parsing as a fragment: + +```js +import {fromHtml} from 'hast-util-from-html-isomorphic' + +const doc = 'Hi!

Hello!

' + +console.log(fromHtml(doc)) + +console.log(fromHtml(doc, {fragment: true})) +``` + +…yields (positional info and data omitted for brevity): + +```js +{ + type: 'root', + children: [ + {type: 'element', tagName: 'html', properties: {}, children: [Array]} + ] +} +``` + +```js +{ + type: 'root', + children: [ + {type: 'element', tagName: 'title', properties: {}, children: [Array]}, + {type: 'element', tagName: 'h1', properties: {}, children: [Array]} + ] +} +``` + +> 👉 **Note**: observe that when a whole document is expected (first example), +> missing elements are opened and closed. + +## Syntax + +HTML is parsed according to WHATWG HTML (the living standard), which is also +followed by browsers such as Chrome and Firefox. + +## Types + +This package is fully typed with [TypeScript][]. +It exports the additional type [`Options`][api-options]. + +## Compatibility + +Projects maintained by the unified collective are compatible with maintained +versions of Node.js. + +When we cut a new major release, we drop support for unmaintained versions of +Node. +This means we try to keep the current release line, +`hast-util-from-html-isomorphic@^1`, compatible with Node.js 16. + +## Security + +Parsing HTML is safe but using user-provided content can open you up to a +[cross-site scripting (XSS)][xss] attack. +Use [`hast-util-santize`][hast-util-sanitize] to make the hast tree safe. + +## Related + +* [`hast-util-from-html`](https://github.com/syntax-tree/hast-util-from-html) + — parse html into hast +* [`hast-util-from-dom`](https://github.com/syntax-tree/hast-util-from-dom) + — parse a DOM tree into hast +* [`hast-util-to-html`](https://github.com/syntax-tree/hast-util-to-html) + — serialize hast +* [`hast-util-sanitize`](https://github.com/syntax-tree/hast-util-sanitize) + — sanitize hast +* [`xast-util-from-xml`][xast-util-from-xml] + — parse XML + +## Contribute + +See [`contributing.md`][contributing] in [`syntax-tree/.github`][health] for +ways to get started. +See [`support.md`][support] for ways to get help. + +This project has a [code of conduct][coc]. +By interacting with this repository, organization, or community you agree to +abide by its terms. + +## License + +[MIT][license] © [Remco Haszing][author] + + + +[build-badge]: https://github.com/syntax-tree/hast-util-from-html-isomorphic/workflows/main/badge.svg + +[build]: https://github.com/syntax-tree/hast-util-from-html-isomorphic/actions + +[coverage-badge]: https://img.shields.io/codecov/c/github/syntax-tree/hast-util-from-html-isomorphic.svg + +[coverage]: https://codecov.io/github/syntax-tree/hast-util-from-html-isomorphic + +[downloads-badge]: https://img.shields.io/npm/dm/hast-util-from-html-isomorphic.svg + +[downloads]: https://www.npmjs.com/package/hast-util-from-html-isomorphic + +[size-badge]: https://img.shields.io/badge/dynamic/json?label=minzipped%20size&query=$.size.compressedSize&url=https://deno.bundlejs.com/?q=hast-util-from-html-isomorphic + +[size]: https://bundlejs.com/?q=hast-util-from-html-isomorphic + +[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg + +[backers-badge]: https://opencollective.com/unified/backers/badge.svg + +[collective]: https://opencollective.com/unified + +[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg + +[chat]: https://github.com/syntax-tree/unist/discussions + +[npm]: https://docs.npmjs.com/cli/install + +[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c + +[esmsh]: https://esm.sh + +[typescript]: https://www.typescriptlang.org + +[license]: license + +[author]: https://github.com/remcohaszing + +[health]: https://github.com/syntax-tree/.github + +[contributing]: https://github.com/syntax-tree/.github/blob/main/contributing.md + +[support]: https://github.com/syntax-tree/.github/blob/main/support.md + +[coc]: https://github.com/syntax-tree/.github/blob/main/code-of-conduct.md + +[xss]: https://en.wikipedia.org/wiki/Cross-site_scripting + +[hast]: https://github.com/syntax-tree/hast + +[root]: https://github.com/syntax-tree/hast#root + +[hast-util-sanitize]: https://github.com/syntax-tree/hast-util-sanitize + +[hast-util-from-dom]: https://github.com/syntax-tree/hast-util-from-dom + +[hast-util-from-html]: https://github.com/syntax-tree/hast-util-from-html + +[hast-util-to-dom]: https://github.com/syntax-tree/hast-util-to-dom + +[hast-util-to-html]: https://github.com/syntax-tree/hast-util-to-html + +[xast-util-from-xml]: https://github.com/syntax-tree/xast-util-from-xml + +[api-from-html-isomorphic]: #fromhtmlisomorphicvalue-options + +[api-options]: #options diff --git a/tools/ui/node_modules/hast-util-from-html/index.d.ts b/tools/ui/node_modules/hast-util-from-html/index.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..7a9f63293102f317959d489c79408b00081fefb1 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html/index.d.ts @@ -0,0 +1,4 @@ +// eslint-disable-next-line @typescript-eslint/triple-slash-reference -- needed to register data. +/// +export {fromHtml} from './lib/index.js' +export type {ErrorCode, ErrorSeverity, OnError, Options} from './lib/types.js' diff --git a/tools/ui/node_modules/hast-util-from-html/index.js b/tools/ui/node_modules/hast-util-from-html/index.js new file mode 100644 index 0000000000000000000000000000000000000000..930467a8082747a55b7741b925d57fab3d7b0a97 --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html/index.js @@ -0,0 +1,2 @@ +// Note: types exposed from `index.d.ts`. +export {fromHtml} from './lib/index.js' diff --git a/tools/ui/node_modules/hast-util-from-html/lib/errors.d.ts b/tools/ui/node_modules/hast-util-from-html/lib/errors.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..f18ca8e819b85c5e2e2849475804be5bfefbdcdf --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html/lib/errors.d.ts @@ -0,0 +1,80 @@ +export namespace errors { + let abandonedHeadElementChild: ErrorInfo; + let abruptClosingOfEmptyComment: ErrorInfo; + let abruptDoctypePublicIdentifier: ErrorInfo; + let abruptDoctypeSystemIdentifier: ErrorInfo; + let absenceOfDigitsInNumericCharacterReference: ErrorInfo; + let cdataInHtmlContent: ErrorInfo; + let characterReferenceOutsideUnicodeRange: ErrorInfo; + let closingOfElementWithOpenChildElements: ErrorInfo; + let controlCharacterInInputStream: ErrorInfo; + let controlCharacterReference: ErrorInfo; + let disallowedContentInNoscriptInHead: ErrorInfo; + let duplicateAttribute: ErrorInfo; + let endTagWithAttributes: ErrorInfo; + let endTagWithTrailingSolidus: ErrorInfo; + let endTagWithoutMatchingOpenElement: ErrorInfo; + let eofBeforeTagName: ErrorInfo; + let eofInCdata: ErrorInfo; + let eofInComment: ErrorInfo; + let eofInDoctype: ErrorInfo; + let eofInElementThatCanContainOnlyText: ErrorInfo; + let eofInScriptHtmlCommentLikeText: ErrorInfo; + let eofInTag: ErrorInfo; + let incorrectlyClosedComment: ErrorInfo; + let incorrectlyOpenedComment: ErrorInfo; + let invalidCharacterSequenceAfterDoctypeName: ErrorInfo; + let invalidFirstCharacterOfTagName: ErrorInfo; + let misplacedDoctype: ErrorInfo; + let misplacedStartTagForHeadElement: ErrorInfo; + let missingAttributeValue: ErrorInfo; + let missingDoctype: ErrorInfo; + let missingDoctypeName: ErrorInfo; + let missingDoctypePublicIdentifier: ErrorInfo; + let missingDoctypeSystemIdentifier: ErrorInfo; + let missingEndTagName: ErrorInfo; + let missingQuoteBeforeDoctypePublicIdentifier: ErrorInfo; + let missingQuoteBeforeDoctypeSystemIdentifier: ErrorInfo; + let missingSemicolonAfterCharacterReference: ErrorInfo; + let missingWhitespaceAfterDoctypePublicKeyword: ErrorInfo; + let missingWhitespaceAfterDoctypeSystemKeyword: ErrorInfo; + let missingWhitespaceBeforeDoctypeName: ErrorInfo; + let missingWhitespaceBetweenAttributes: ErrorInfo; + let missingWhitespaceBetweenDoctypePublicAndSystemIdentifiers: ErrorInfo; + let nestedComment: ErrorInfo; + let nestedNoscriptInHead: ErrorInfo; + let nonConformingDoctype: ErrorInfo; + let nonVoidHtmlElementStartTagWithTrailingSolidus: ErrorInfo; + let noncharacterCharacterReference: ErrorInfo; + let noncharacterInInputStream: ErrorInfo; + let nullCharacterReference: ErrorInfo; + let openElementsLeftAfterEof: ErrorInfo; + let surrogateCharacterReference: ErrorInfo; + let surrogateInInputStream: ErrorInfo; + let unexpectedCharacterAfterDoctypeSystemIdentifier: ErrorInfo; + let unexpectedCharacterInAttributeName: ErrorInfo; + let unexpectedCharacterInUnquotedAttributeValue: ErrorInfo; + let unexpectedEqualsSignBeforeAttributeName: ErrorInfo; + let unexpectedNullCharacter: ErrorInfo; + let unexpectedQuestionMarkInsteadOfTagName: ErrorInfo; + let unexpectedSolidusInTag: ErrorInfo; + let unknownNamedCharacterReference: ErrorInfo; +} +/** + * Info on a `parse5` error. + */ +export type ErrorInfo = { + /** + * Reason of error. + */ + reason: string; + /** + * More info on error. + */ + description: string; + /** + * Turn off if this is not documented in the html5 spec (optional). + */ + url?: false; +}; +//# sourceMappingURL=errors.d.ts.map \ No newline at end of file diff --git a/tools/ui/node_modules/hast-util-from-html/lib/errors.d.ts.map b/tools/ui/node_modules/hast-util-from-html/lib/errors.d.ts.map new file mode 100644 index 0000000000000000000000000000000000000000..5a7fa5c51663c5708d8f016353a868efe89ce88f --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html/lib/errors.d.ts.map @@ -0,0 +1 @@ +{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["errors.js"],"names":[],"mappings":";mCAYa,SAAS;qCAOT,SAAS;uCAKT,SAAS;uCAMT,SAAS;oDAMT,SAAS;4BAMT,SAAS;+CAMT,SAAS;+CAMT,SAAS;uCAOT,SAAS;mCAMT,SAAS;2CAMT,SAAS;4BAOT,SAAS;8BAMT,SAAS;mCAKT,SAAS;0CAKT,SAAS;0BAMT,SAAS;oBAKT,SAAS;sBAKT,SAAS;sBAKT,SAAS;4CAMT,SAAS;wCAMT,SAAS;kBAKT,SAAS;kCAKT,SAAS;kCAKT,SAAS;kDAKT,SAAS;wCAKT,SAAS;0BAKT,SAAS;yCAMT,SAAS;+BAOT,SAAS;wBAMT,SAAS;4BAMT,SAAS;wCAKT,SAAS;wCAKT,SAAS;2BAMT,SAAS;mDAKT,SAAS;mDAKT,SAAS;iDAKT,SAAS;oDAKT,SAAS;oDAKT,SAAS;4CAKT,SAAS;4CAKT,SAAS;mEAKT,SAAS;uBAMT,SAAS;8BAKT,SAAS;8BAOT,SAAS;uDAOT,SAAS;wCAKT,SAAS;mCAMT,SAAS;gCAKT,SAAS;kCAKT,SAAS;qCAMT,SAAS;gCAMT,SAAS;yDAMT,SAAS;4CAKT,SAAS;qDAMT,SAAS;iDAKT,SAAS;iCAKT,SAAS;gDAMT,SAAS;gCAKT,SAAS;wCAMT,SAAS;;;;;;;;;YAnVR,MAAM;;;;iBAEN,MAAM;;;;UAEN,KAAK"} \ No newline at end of file diff --git a/tools/ui/node_modules/hast-util-from-html/lib/errors.js b/tools/ui/node_modules/hast-util-from-html/lib/errors.js new file mode 100644 index 0000000000000000000000000000000000000000..381c1739c49037edac274d58d969a26c0a91c5cb --- /dev/null +++ b/tools/ui/node_modules/hast-util-from-html/lib/errors.js @@ -0,0 +1,349 @@ +/** + * @typedef ErrorInfo + * Info on a `parse5` error. + * @property {string} reason + * Reason of error. + * @property {string} description + * More info on error. + * @property {false} [url] + * Turn off if this is not documented in the html5 spec (optional). + */ + +export const errors = { + /** @type {ErrorInfo} */ + abandonedHeadElementChild: { + reason: 'Unexpected metadata element after head', + description: + 'Unexpected element after head. Expected the element before ``', + url: false + }, + /** @type {ErrorInfo} */ + abruptClosingOfEmptyComment: { + reason: 'Unexpected abruptly closed empty comment', + description: 'Unexpected `>` or `->`. Expected `-->` to close comments' + }, + /** @type {ErrorInfo} */ + abruptDoctypePublicIdentifier: { + reason: 'Unexpected abruptly closed public identifier', + description: + 'Unexpected `>`. Expected a closing `"` or `\'` after the public identifier' + }, + /** @type {ErrorInfo} */ + abruptDoctypeSystemIdentifier: { + reason: 'Unexpected abruptly closed system identifier', + description: + 'Unexpected `>`. Expected a closing `"` or `\'` after the identifier identifier' + }, + /** @type {ErrorInfo} */ + absenceOfDigitsInNumericCharacterReference: { + reason: 'Unexpected non-digit at start of numeric character reference', + description: + 'Unexpected `%c`. Expected `[0-9]` for decimal references or `[0-9a-fA-F]` for hexadecimal references' + }, + /** @type {ErrorInfo} */ + cdataInHtmlContent: { + reason: 'Unexpected CDATA section in HTML', + description: + 'Unexpected `` in ``', + description: + 'Unexpected text character `%c`. Only use text in `